@deephaven/chart 0.43.0 → 0.44.1-beta.0

package/dist/ChartUtils.js

@@ -0,0 +1,1435 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import Log from '@deephaven/log';
+import { TableUtils } from '@deephaven/jsapi-utils';
+import set from 'lodash.set';
+import { assertNotNull } from '@deephaven/utils';
+import ChartTheme from "./ChartTheme.js";
+var log = Log.module('ChartUtils');
+var BUSINESS_COLUMN_TYPE = 'io.deephaven.time.DateTime';
+var MILLIS_PER_HOUR = 3600000;
+var NANOS_PER_MILLI = 1000000;
+function isDateWrapper(value) {
+  return value.asDate !== undefined;
+}
+function isLongWrapper(value) {
+  return value.asNumber !== undefined;
+}
+function isDateTimeColumnFormatter(value) {
+  return value.dhTimeZone !== undefined;
+}
+function isRangedPlotlyAxis(value) {
+  return value != null && value.range != null && (value.autorange === false || value.autorange === undefined);
+}
+class ChartUtils {
+  /**
+   * Generate the plotly error bar data from the passed in data.
+   * Iris passes in the values as absolute, plotly needs them as relative.
+   * @param x The main data array
+   * @param xLow The absolute low values
+   * @param xHigh
+   *
+   * @returns The error_x object required by plotly, or null if none is required
+   */
+  static getPlotlyErrorBars(x, xLow, xHigh) {
+    var array = xHigh.map((value, i) => value - x[i]);
+    var arrayminus = xLow.map((value, i) => x[i] - value);
+    return {
+      type: 'data',
+      symmetric: false,
+      array,
+      arrayminus
+    };
+  }
+  static convertNumberPrefix(prefix) {
+    return prefix.replace(/\u00A4\u00A4/g, 'USD').replace(/\u00A4/g, '$');
+  }
+  static getPlotlyNumberFormat(formatter, columnType, formatPattern) {
+    if (!formatPattern) {
+      return null;
+    }
+
+    // We translate java formatting: https://docs.oracle.com/javase/7/docs/api/java/text/DecimalFormat.html
+    // Into d3 number formatting: https://github.com/d3/d3-format
+    // We can't translate number formatting exactly, but should be able to translate the most common cases
+    // First split it into the subpatterns; currently only handling the positive subpattern, ignoring the rest
+    var subpatterns = formatPattern.split(';');
+    var matchArray = subpatterns[0].match(/^([^#,0.]*)([#,]*)([0,]*)(\.?)(0*)(#*)(E?0*)(%?)(.*)/);
+    assertNotNull(matchArray);
+    var [, prefix, placeholderDigits, zeroDigits,, decimalDigits, optionalDecimalDigits, numberType, percentSign, suffix] = matchArray;
+    var paddingLength = zeroDigits.replace(',', '').length;
+    var isCommaSeparated = placeholderDigits.indexOf(',') >= 0 || zeroDigits.indexOf(',') >= 0;
+    var comma = isCommaSeparated ? ',' : '';
+    var plotlyNumberType = numberType != null && numberType !== '' ? 'e' : 'f';
+    var type = percentSign !== '' ? percentSign : plotlyNumberType;
+    var decimalLength = decimalDigits.length + optionalDecimalDigits.length;
+    // IDS-4565 Plotly uses an older version of d3 which doesn't support the trim option or negative brackets
+    // If plotly updates it's d3 version, this should be re-enabled
+    // const trimOption = optionalDecimalDigits.length > 0 ? '~' : '';
+    var trimOption = '';
+    var tickformat = "0".concat(paddingLength).concat(comma, ".").concat(decimalLength).concat(trimOption).concat(type);
+    var tickprefix = ChartUtils.convertNumberPrefix(prefix);
+    // prefix and suffix are processed the same
+    var ticksuffix = ChartUtils.convertNumberPrefix(suffix);
+    return {
+      tickformat,
+      tickprefix,
+      ticksuffix,
+      automargin: true
+    };
+  }
+
+  /**
+   * Adds tick spacing for an axis that has gapBetweenMajorTicks defined.
+   *
+   * @param axisFormat the current axis format, may be null
+   * @param axis the current axis
+   * @param isDateType indicates if the columns is a date type
+   */
+  static addTickSpacing(axisFormat, axis, isDateType) {
+    var {
+      gapBetweenMajorTicks
+    } = axis;
+    if (gapBetweenMajorTicks > 0) {
+      var updatedFormat = axisFormat || {};
+      var tickSpacing = gapBetweenMajorTicks;
+      if (isDateType) {
+        // Need to convert from nanoseconds to milliseconds
+        tickSpacing = gapBetweenMajorTicks / NANOS_PER_MILLI;
+      }
+      if (axis.log) {
+        tickSpacing = Math.log(tickSpacing);
+      }
+      // Note that tickmode defaults to 'auto'
+      updatedFormat.tickmode = 'linear';
+      updatedFormat.dtick = tickSpacing;
+      return updatedFormat;
+    }
+    return axisFormat;
+  }
+
+  /**
+   * Retrieve the data source for a given axis in a chart
+   * @param chart The chart to get the source for
+   * @param axis The axis to find the source for
+   * @returns The first source matching this axis
+   */
+  static getSourceForAxis(chart, axis) {
+    for (var i = 0; i < chart.series.length; i += 1) {
+      var series = chart.series[i];
+      for (var j = 0; j < series.sources.length; j += 1) {
+        var source = series.sources[j];
+        if (source.axis === axis) {
+          return source;
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Get visibility setting for the series object
+   * @param  name The series name to get the visibility for
+   * @param  settings Chart settings
+   * @returns True for visible series and 'legendonly' for hidden
+   */
+  static getSeriesVisibility(name, settings) {
+    if (settings != null && settings.hiddenSeries != null && settings.hiddenSeries.includes(name)) {
+      return 'legendonly';
+    }
+    return true;
+  }
+
+  /**
+   * Get hidden labels array from chart settings
+   * @param settings Chart settings
+   * @returns Array of hidden series names
+   */
+  static getHiddenLabels(settings) {
+    if (settings !== null && settings !== void 0 && settings.hiddenSeries) {
+      return [...settings.hiddenSeries];
+    }
+    return [];
+  }
+
+  /**
+   * Create a default series data object. Apply styling to the object afterward.
+   * @returns A simple series data object with no styling
+   */
+  static makeSeriesData(type, mode, name, showLegend) {
+    var orientation = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : ChartUtils.ORIENTATION.VERTICAL;
+    return {
+      type,
+      mode,
+      name,
+      orientation,
+      showlegend: showLegend !== null && showLegend !== void 0 ? showLegend : undefined
+    };
+  }
+
+  /**
+   * Get the Plotly marker symbol for the provided Deephaven shape
+   * Deephaven shapes: https://deephaven.io/enterprise/docs/plotting/visual-formatting/#point-formatting
+   * Plotly shapes: https://plotly.com/javascript/reference/scattergl/#scattergl-marker-symbol
+   * Table of plotly shapes: https://plotly.com/python/marker-style/#custom-marker-symbols
+   * @param deephavenShape Deephaven shape to get the marker symbol for
+   */
+  static getMarkerSymbol(deephavenShape) {
+    switch (deephavenShape) {
+      case 'SQUARE':
+        return 'square';
+      case 'CIRCLE':
+        return 'circle';
+      case 'DIAMOND':
+        return 'diamond';
+      case 'UP_TRIANGLE':
+        return 'triangle-up';
+      case 'DOWN_TRIANGLE':
+        return 'triangle-down';
+      case 'RIGHT_TRIANGLE':
+        return 'triangle-right';
+      case 'LEFT_TRIANGLE':
+        return 'triangle-left';
+      // There don't seem to be any plotly equivalents for ellipse or rectangles
+      // Rectangles could be `line-ew`, `line-ns`, or `hourglass` and `bowtie` instead?
+      // Ellipse could be `asterisk` or `diamond-wide` instead?
+      // Just throw an error, we've already got a bunch of types.
+      case 'ELLIPSE':
+      case 'HORIZONTAL_RECTANGLE':
+      case 'VERTICAL_RECTANGLE':
+      default:
+        throw new Error("Unrecognized shape ".concat(deephavenShape));
+    }
+  }
+
+  /**
+   * Get all axes for a given `Figure`. Iterates through all charts axes and concatenates them.
+   * @param figure Figure to get all axes for
+   */
+  static getAllAxes(figure) {
+    return figure.charts.reduce((axes, chart) => [...axes, ...chart.axes], []);
+  }
+
+  /**
+   * Retrieve the chart that contains the passed in series from the figure
+   * @param figure The figure to retrieve the chart from
+   * @param series The series to get the chart for
+   */
+  static getChartForSeries(figure, series) {
+    var {
+      charts
+    } = figure;
+    for (var i = 0; i < charts.length; i += 1) {
+      var _chart = charts[i];
+      for (var j = 0; j < _chart.series.length; j += 1) {
+        if (series === _chart.series[j]) {
+          return _chart;
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Get an object mapping axis to their ranges
+   * @param layout The plotly layout object to get the ranges from
+   * @returns An object mapping the axis name to it's range
+   */
+  static getLayoutRanges(layout) {
+    var ranges = {};
+    var keys = Object.keys(layout).filter(key => key.indexOf('axis') >= 0);
+    for (var i = 0; i < keys.length; i += 1) {
+      var key = keys[i];
+      var value = layout[key];
+      if (isRangedPlotlyAxis(value)) {
+        // Only want to add the range if it's not autoranged
+        ranges[key] = [...value.range];
+      }
+    }
+    return ranges;
+  }
+  static getAxisLayoutProperty(axisProperty, axisIndex) {
+    var axisIndexString = axisIndex > 0 ? "".concat(axisIndex + 1) : '';
+    return "".concat(axisProperty !== null && axisProperty !== void 0 ? axisProperty : '', "axis").concat(axisIndexString);
+  }
+
+  /**
+   * Converts an open or close period to a declimal. e.g '09:30" to 9.5
+   *
+   * @param period the open or close value of the period
+   */
+  static periodToDecimal(period) {
+    var values = period.split(':');
+    return Number(values[0]) + Number(values[1]) / 60;
+  }
+
+  /**
+   * Groups an array and returns a map
+   * @param array The object to group
+   * @param property The property name to group by
+   * @returns A map containing the items grouped by their values for the property
+   */
+  static groupArray(array, property) {
+    return array.reduce((result, item) => {
+      var _result$get;
+      var key = item[property];
+      var group = (_result$get = result.get(key)) !== null && _result$get !== void 0 ? _result$get : [];
+      group.push(item);
+      result.set(key, group);
+      return result;
+    }, new Map());
+  }
+
+  /**
+   * Parses the colorway property of a theme and returns an array of colors
+   * Theme could have a single string with space separated colors or an array of strings representing the colorway
+   * @param theme The theme to get colorway from
+   * @returns Colorway array for the theme
+   */
+  static getColorwayFromTheme() {
+    var theme = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ChartTheme;
+    var colorway = [];
+    if (theme.colorway) {
+      if (Array.isArray(theme.colorway)) {
+        colorway = theme.colorway;
+      } else if (typeof theme.colorway === 'string') {
+        colorway = theme.colorway.split(' ');
+      } else {
+        log.warn("Unable to handle colorway property: ".concat(theme.colorway));
+      }
+    }
+    return colorway;
+  }
+  static titleFromSettings(settings) {
+    var {
+      series,
+      xAxis,
+      title = "".concat((series !== null && series !== void 0 ? series : []).join(', '), " by ").concat(xAxis)
+    } = settings;
+    return title;
+  }
+  constructor(dh) {
+    _defineProperty(this, "dh", void 0);
+    _defineProperty(this, "daysOfWeek", void 0);
+    this.dh = dh;
+    this.daysOfWeek = Object.freeze(dh.calendar.DayOfWeek.values());
+  }
+
+  /**
+   * Retrieve the axis formats from the provided figure.
+   * Currently defaults to just the x/y axes.
+   * @param figure The figure to get the axis formats for
+   * @param formatter The formatter to use when getting the axis format
+   * @returns A map of axis layout property names to axis formats
+   */
+  getAxisFormats(figure, formatter) {
+    var _this = this;
+    var axisFormats = new Map();
+    var nullFormat = {
+      tickformat: null,
+      ticksuffix: null
+    };
+    var allAxes = ChartUtils.getAllAxes(figure);
+    var axisTypeMap = ChartUtils.groupArray(allAxes, 'type');
+    var {
+      charts
+    } = figure;
+    for (var i = 0; i < charts.length; i += 1) {
+      var _chart2 = charts[i];
+      for (var j = 0; j < _chart2.series.length; j += 1) {
+        var series = _chart2.series[j];
+        var {
+          sources
+        } = series;
+        var axisSources = sources.filter(source => source.axis);
+        var _loop = function _loop() {
+          var source = axisSources[k];
+          var {
+            axis
+          } = source;
+          var {
+            type: axisType
+          } = axis;
+          var typeAxes = axisTypeMap.get(axisType);
+          assertNotNull(typeAxes);
+          var axisIndex = typeAxes.indexOf(axis);
+          var axisProperty = _this.getAxisPropertyName(axisType);
+          if (axisProperty != null) {
+            var axisLayoutProperty = ChartUtils.getAxisLayoutProperty(axisProperty, axisIndex);
+            if (axisFormats.has(axisLayoutProperty)) {
+              log.debug("".concat(axisLayoutProperty, " already added."));
+            } else {
+              log.debug("Adding ".concat(axisLayoutProperty, " to axisFormats."));
+              var axisFormat = _this.getPlotlyAxisFormat(source, formatter);
+              if (axisFormat === null) {
+                axisFormats.set(axisLayoutProperty, nullFormat);
+              } else {
+                axisFormats.set(axisLayoutProperty, axisFormat);
+                var {
+                  businessCalendar
+                } = axis;
+                if (businessCalendar != null) {
+                  var rangebreaks = [];
+                  var {
+                    businessPeriods,
+                    businessDays,
+                    holidays,
+                    timeZone: calendarTimeZone
+                  } = businessCalendar;
+                  var typeFormatter = formatter === null || formatter === void 0 ? void 0 : formatter.getColumnTypeFormatter(BUSINESS_COLUMN_TYPE);
+                  var formatterTimeZone;
+                  if (isDateTimeColumnFormatter(typeFormatter)) {
+                    formatterTimeZone = typeFormatter.dhTimeZone;
+                  }
+                  var timeZoneDiff = formatterTimeZone ? (calendarTimeZone.standardOffset - formatterTimeZone.standardOffset) / 60 : 0;
+                  if (holidays.length > 0) {
+                    rangebreaks.push(..._this.createRangeBreakValuesFromHolidays(holidays, calendarTimeZone, formatterTimeZone));
+                  }
+                  businessPeriods.forEach(period => rangebreaks.push({
+                    pattern: 'hour',
+                    bounds: [ChartUtils.periodToDecimal(period.close) + timeZoneDiff, ChartUtils.periodToDecimal(period.open) + timeZoneDiff]
+                  }));
+                  // If there are seven business days, then there is no weekend
+                  if (businessDays.length < _this.daysOfWeek.length) {
+                    _this.createBoundsFromDays(businessDays).forEach(weekendBounds => rangebreaks.push({
+                      pattern: 'day of week',
+                      bounds: weekendBounds
+                    }));
+                  }
+                  axisFormat.rangebreaks = rangebreaks;
+                }
+                if (axisFormats.size === _chart2.axes.length) {
+                  return {
+                    v: axisFormats
+                  };
+                }
+              }
+            }
+          }
+        };
+        for (var k = 0; k < axisSources.length; k += 1) {
+          var _ret = _loop();
+          if (typeof _ret === "object") return _ret.v;
+        }
+      }
+    }
+    return axisFormats;
+  }
+
+  /**
+   * Converts the Iris plot style into a plotly chart type
+   * @param plotStyle The plotStyle to use, see dh.plot.SeriesPlotStyle
+   * @param isBusinessTime If the plot is using business time for an axis
+   */
+  getPlotlyChartType(plotStyle, isBusinessTime) {
+    var {
+      dh
+    } = this;
+    switch (plotStyle) {
+      case dh.plot.SeriesPlotStyle.SCATTER:
+        // scattergl mode is more performant, but doesn't support the rangebreaks we need for businessTime calendars
+        return !isBusinessTime ? 'scattergl' : 'scatter';
+      case dh.plot.SeriesPlotStyle.LINE:
+        // There is also still some artifacting bugs with scattergl: https://github.com/plotly/plotly.js/issues/3522
+        // The artifacting only occurs on line plots, which we can draw with fairly decent performance using SVG paths
+        // Once the above plotly issue is fixed, scattergl should be used here (when !isBusinessTime)
+        return 'scatter';
+      case dh.plot.SeriesPlotStyle.BAR:
+      case dh.plot.SeriesPlotStyle.STACKED_BAR:
+        return 'bar';
+      case dh.plot.SeriesPlotStyle.PIE:
+        return 'pie';
+      case dh.plot.SeriesPlotStyle.TREEMAP:
+        return 'treemap';
+      case dh.plot.SeriesPlotStyle.HISTOGRAM:
+        return 'histogram';
+      case dh.plot.SeriesPlotStyle.OHLC:
+        return 'ohlc';
+      default:
+        return undefined;
+    }
+  }
+
+  /**
+   * Converts the Iris plot style into a plotly chart mode
+   * @param plotStyle The plotStyle to use, see dh.plot.SeriesPlotStyle.*
+   * @param areLinesVisible Whether lines are visible or not
+   * @param areShapesVisible Whether shapes are visible or not
+   */
+  getPlotlyChartMode(plotStyle, areLinesVisible, areShapesVisible) {
+    var {
+      dh
+    } = this;
+    var modes = new Set();
+    switch (plotStyle) {
+      case dh.plot.SeriesPlotStyle.SCATTER:
+        // Default to only showing shapes in scatter plots
+        if (areLinesVisible !== null && areLinesVisible !== void 0 ? areLinesVisible : false) {
+          modes.add(ChartUtils.MODE_LINES);
+        }
+        if (areShapesVisible !== null && areShapesVisible !== void 0 ? areShapesVisible : true) {
+          modes.add(ChartUtils.MODE_MARKERS);
+        }
+        break;
+      case dh.plot.SeriesPlotStyle.LINE:
+        // Default to only showing lines in line series
+        if (areLinesVisible !== null && areLinesVisible !== void 0 ? areLinesVisible : true) {
+          modes.add(ChartUtils.MODE_LINES);
+        }
+        if (areShapesVisible !== null && areShapesVisible !== void 0 ? areShapesVisible : false) {
+          modes.add(ChartUtils.MODE_MARKERS);
+        }
+        break;
+      default:
+        break;
+    }
+    return modes.size > 0 ? [...modes].join('+') : undefined;
+  }
+
+  /**
+   * Get the property to set on the series data for plotly
+   * @param plotStyle The plot style of the series
+   * @param sourceType The source type for the series
+   */
+  getPlotlyProperty(plotStyle, sourceType) {
+    var {
+      dh
+    } = this;
+    switch (plotStyle) {
+      case dh.plot.SeriesPlotStyle.PIE:
+        switch (sourceType) {
+          case dh.plot.SourceType.X:
+            return 'labels';
+          case dh.plot.SourceType.Y:
+            return 'values';
+          default:
+            break;
+        }
+        break;
+      case dh.plot.SeriesPlotStyle.OHLC:
+        switch (sourceType) {
+          case dh.plot.SourceType.TIME:
+            return 'x';
+          default:
+            break;
+        }
+        break;
+      case dh.plot.SeriesPlotStyle.TREEMAP:
+        switch (sourceType) {
+          case dh.plot.SourceType.X:
+            return 'ids';
+          case dh.plot.SourceType.Y:
+            return 'values';
+          case dh.plot.SourceType.LABEL:
+            return 'labels';
+          case dh.plot.SourceType.PARENT:
+            return 'parents';
+          case dh.plot.SourceType.COLOR:
+            return 'marker.colors';
+          default:
+            break;
+        }
+        break;
+      default:
+        break;
+    }
+    switch (sourceType) {
+      case dh.plot.SourceType.X:
+        return 'x';
+      case dh.plot.SourceType.Y:
+        return 'y';
+      case dh.plot.SourceType.Z:
+        return 'z';
+      case dh.plot.SourceType.X_LOW:
+        return 'xLow';
+      case dh.plot.SourceType.X_HIGH:
+        return 'xHigh';
+      case dh.plot.SourceType.Y_LOW:
+        return 'yLow';
+      case dh.plot.SourceType.Y_HIGH:
+        return 'yHigh';
+      case dh.plot.SourceType.TIME:
+        return 'time';
+      case dh.plot.SourceType.OPEN:
+        return 'open';
+      case dh.plot.SourceType.HIGH:
+        return 'high';
+      case dh.plot.SourceType.LOW:
+        return 'low';
+      case dh.plot.SourceType.CLOSE:
+        return 'close';
+      case dh.plot.SourceType.SHAPE:
+        return 'shape';
+      case dh.plot.SourceType.SIZE:
+        return 'size';
+      case dh.plot.SourceType.LABEL:
+        return 'label';
+      case dh.plot.SourceType.COLOR:
+        return 'color';
+      case dh.plot.SourceType.PARENT:
+        return 'parent';
+      case dh.plot.SourceType.HOVER_TEXT:
+        return 'hovertext';
+      case dh.plot.SourceType.TEXT:
+        return 'text';
+      default:
+        throw new Error("Unrecognized source type: ".concat(sourceType));
+    }
+  }
+  getPlotlySeriesOrientation(series) {
+    var _sources$, _sources$$axis;
+    var {
+      dh
+    } = this;
+    var {
+      sources
+    } = series;
+    if (sources.length === 2 && ((_sources$ = sources[0]) === null || _sources$ === void 0 ? void 0 : (_sources$$axis = _sources$.axis) === null || _sources$$axis === void 0 ? void 0 : _sources$$axis.type) === dh.plot.AxisType.Y) {
+      return ChartUtils.ORIENTATION.HORIZONTAL;
+    }
+    return ChartUtils.ORIENTATION.VERTICAL;
+  }
+
+  /**
+   * Create a data series (trace) for use with plotly
+   * @param series The series to create the series data with
+   * @param axisTypeMap The map of axes grouped by type
+   * @param seriesVisibility Visibility setting for the series
+   * @param theme The theme properties for the plot. See ChartTheme.js for an example
+   * @returns The series data (trace) object for use with plotly.
+   */
+  makeSeriesDataFromSeries(series, axisTypeMap, seriesVisibility) {
+    var showLegend = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+    var theme = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : ChartTheme;
+    var {
+      name,
+      isLinesVisible,
+      isShapesVisible,
+      plotStyle,
+      lineColor,
+      shapeColor,
+      sources,
+      shape,
+      shapeSize
+    } = series;
+    var isBusinessTime = sources.some(source => {
+      var _source$axis;
+      return (_source$axis = source.axis) === null || _source$axis === void 0 ? void 0 : _source$axis.businessCalendar;
+    });
+    var type = this.getChartType(plotStyle, isBusinessTime);
+    var mode = this.getPlotlyChartMode(plotStyle, isLinesVisible !== null && isLinesVisible !== void 0 ? isLinesVisible : undefined, isShapesVisible !== null && isShapesVisible !== void 0 ? isShapesVisible : undefined);
+    var orientation = this.getPlotlySeriesOrientation(series);
+    var seriesData = ChartUtils.makeSeriesData(type, mode, name, showLegend, orientation);
+    this.addSourcesToSeriesData(seriesData, plotStyle, sources, axisTypeMap);
+    this.addStylingToSeriesData(seriesData, plotStyle, theme, lineColor, shapeColor, shape, shapeSize, seriesVisibility);
+    return seriesData;
+  }
+  addSourcesToSeriesData(seriesDataParam, plotStyle, sources, axisTypeMap) {
+    var seriesData = seriesDataParam;
+    for (var k = 0; k < sources.length; k += 1) {
+      var source = sources[k];
+      var {
+        axis: _axis,
+        type: sourceType
+      } = source;
+      var dataAttributeName = this.getPlotlyProperty(plotStyle, sourceType);
+      set(seriesData, dataAttributeName, []);
+      var axisProperty = _axis != null ? this.getAxisPropertyName(_axis.type) : null;
+      if (axisProperty != null) {
+        var axes = axisTypeMap.get(_axis.type);
+        if (axes) {
+          var axisIndex = axes.indexOf(_axis);
+          var axisIndexString = axisIndex > 0 ? "".concat(axisIndex + 1) : '';
+          seriesData["".concat(axisProperty, "axis")] = "".concat(axisProperty).concat(axisIndexString);
+        }
+      }
+    }
+  }
+  addStylingToSeriesData(seriesDataParam, plotStyle) {
+    var theme = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ChartTheme;
+    var lineColor = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+    var shapeColor = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
+    var shape = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : null;
+    var shapeSize = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : null;
+    var seriesVisibility = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : null;
+    var {
+      dh
+    } = this;
+    var seriesData = seriesDataParam;
+    // Add some empty objects so we can fill them in later with details without checking for existence
+    seriesData.marker = {
+      line: {}
+    }; // border line width on markers
+    seriesData.line = {
+      width: 1 // default line width for lines, should eventually be able to override
+    };
+
+    if (plotStyle === dh.plot.SeriesPlotStyle.AREA) {
+      seriesData.fill = 'tozeroy';
+    } else if (plotStyle === dh.plot.SeriesPlotStyle.STACKED_AREA) {
+      seriesData.stackgroup = 'stack';
+    } else if (plotStyle === dh.plot.SeriesPlotStyle.STEP) {
+      seriesData.line.shape = 'hv'; // plot.ly horizontal then vertical step styling
+    } else if (plotStyle === dh.plot.SeriesPlotStyle.HISTOGRAM) {
+      // The default histfunc in plotly is 'count', but the data passed up from the API provides explicit x/y values and bins
+      // Since it's converted to bar, just set the widths of each bar
+      seriesData.width = [];
+      if (seriesData.marker.line !== undefined) {
+        Object.assign(seriesData.marker.line, {
+          color: theme.paper_bgcolor,
+          width: 1
+        });
+      }
+    } else if (plotStyle === dh.plot.SeriesPlotStyle.OHLC) {
+      seriesData.increasing = {
+        line: {
+          color: theme.ohlc_increasing
+        }
+      };
+      seriesData.decreasing = {
+        line: {
+          color: theme.ohlc_decreasing
+        }
+      };
+    } else if (plotStyle === dh.plot.SeriesPlotStyle.PIE) {
+      seriesData.textinfo = 'label+percent';
+
+      // TODO Open DefinitelyTyped/Plotly PR to mark family and size as optional
+      // https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/plotly.js/lib/traces/pie.d.ts#L6
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      seriesData.outsidetextfont = {
+        color: theme.title_color
+      };
+    } else if (plotStyle === dh.plot.SeriesPlotStyle.TREEMAP) {
+      seriesData.hoverinfo = 'text';
+      seriesData.textinfo = 'label+text';
+      seriesData.tiling = {
+        packing: 'squarify',
+        pad: 0
+      };
+      seriesData.textposition = 'middle center';
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      seriesData.outsidetextfont = {
+        color: theme.title_color
+      };
+    }
+    if (lineColor != null) {
+      if (plotStyle === dh.plot.SeriesPlotStyle.BAR) {
+        seriesData.marker.color = lineColor;
+      } else {
+        seriesData.line.color = lineColor;
+      }
+    }
+    if (shapeColor != null) {
+      seriesData.marker.color = shapeColor;
+    }
+    if (shape != null && shape.length > 0) {
+      try {
+        seriesData.marker.symbol = ChartUtils.getMarkerSymbol(shape);
+      } catch (e) {
+        log.warn('Unable to handle shape', shape, ':', e);
+      }
+    }
+    if (shapeSize != null) {
+      seriesData.marker.size = shapeSize * ChartUtils.DEFAULT_MARKER_SIZE;
+    }
+
+    // Skipping pie charts
+    // Pie slice visibility is configured in chart layout instead of series data
+    if (seriesVisibility != null && plotStyle !== dh.plot.SeriesPlotStyle.PIE) {
+      seriesData.visible = seriesVisibility;
+    }
+  }
+  getChartType(plotStyle, isBusinessTime) {
+    var {
+      dh
+    } = this;
+    switch (plotStyle) {
+      case dh.plot.SeriesPlotStyle.HISTOGRAM:
+        // When reading data from the `Figure`, it already provides bins and values, so rather than using
+        // plot.ly to calculate the bins and sum values, just convert it to a bar chart
+        return 'bar';
+      default:
+        return this.getPlotlyChartType(plotStyle, isBusinessTime);
+    }
+  }
+
+  /**
+   * Return the plotly axis property name
+   * @param axisType The axis type to get the property name for
+   */
+  getAxisPropertyName(axisType) {
+    var {
+      dh
+    } = this;
+    switch (axisType) {
+      case dh.plot.AxisType.X:
+        return 'x';
+      case dh.plot.AxisType.Y:
+        return 'y';
+      default:
+        return null;
+    }
+  }
+
+  /**
+   * Returns the plotly "side" value for the provided axis position
+   * @param axisPosition The Iris AxisPosition of the axis
+   */
+  getAxisSide(axisPosition) {
+    var {
+      dh
+    } = this;
+    switch (axisPosition) {
+      case dh.plot.AxisPosition.BOTTOM:
+        return 'bottom';
+      case dh.plot.AxisPosition.TOP:
+        return 'top';
+      case dh.plot.AxisPosition.LEFT:
+        return 'left';
+      case dh.plot.AxisPosition.RIGHT:
+        return 'right';
+      default:
+        return undefined;
+    }
+  }
+
+  /**
+   * Update the layout with all the axes information for the provided figure
+   * @param figure Figure to update the axes for
+   * @param layoutParam Layout object to update in place
+   * @param chartAxisRangeParser Function to retrieve the axis range parser
+   * @param plotWidth Width of the plot in pixels
+   * @param plotHeight Height of the plot in pixels
+   * @param theme Theme used for displaying the plot
+   */
+  updateFigureAxes(layoutParam, figure, chartAxisRangeParser) {
+    var plotWidth = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+    var plotHeight = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
+    var theme = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : ChartTheme;
+    var layout = layoutParam;
+    var figureAxes = ChartUtils.getAllAxes(figure);
+    for (var i = 0; i < figure.charts.length; i += 1) {
+      var _chart3 = figure.charts[i];
+      var axisRangeParser = chartAxisRangeParser === null || chartAxisRangeParser === void 0 ? void 0 : chartAxisRangeParser(_chart3);
+      var bounds = this.getChartBounds(figure, _chart3, plotWidth, plotHeight);
+      this.updateLayoutAxes(layout, _chart3.axes, figureAxes, plotWidth, plotHeight, bounds, axisRangeParser, theme);
+    }
+    this.removeStaleAxes(layout, figureAxes);
+  }
+  getChartBounds(figure, chart, plotWidth, plotHeight) {
+    var _axisPositionMap$get;
+    var {
+      dh
+    } = this;
+    var {
+      cols,
+      rows
+    } = figure;
+    var {
+      column,
+      colspan,
+      row,
+      rowspan
+    } = chart;
+    var endColumn = column + colspan;
+    var endRow = row + rowspan;
+    var columnSize = 1 / cols;
+    var rowSize = 1 / rows;
+    var xMarginSize = ChartUtils.AXIS_SIZE_PX / plotWidth;
+    var yMarginSize = ChartUtils.AXIS_SIZE_PX / plotHeight;
+    var bounds = {
+      // Need to invert the row positioning so the first one defined shows up on top instead of the bottom, since coordinates start in bottom left
+      bottom: (rows - endRow) * rowSize + (endRow < rows ? yMarginSize / 2 : 0),
+      top: (rows - row) * rowSize - (row > 0 ? yMarginSize / 2 : 0),
+      left: column * columnSize + (column > 0 ? xMarginSize / 2 : 0),
+      right: endColumn * columnSize - (endColumn < cols ? xMarginSize / 2 : 0)
+    };
+
+    // Adjust the bounds based on where the legend is
+    // For now, always assume the legend is shown on the right
+    var axisPositionMap = ChartUtils.groupArray(chart.axes, 'position');
+    var rightAxes = (_axisPositionMap$get = axisPositionMap.get(dh.plot.AxisPosition.RIGHT)) !== null && _axisPositionMap$get !== void 0 ? _axisPositionMap$get : [];
+    if (rightAxes.length > 0) {
+      if (plotWidth > 0) {
+        bounds.right -= (bounds.right - bounds.left) * Math.max(0, Math.min(ChartUtils.LEGEND_WIDTH_PX / plotWidth, ChartUtils.MAX_LEGEND_SIZE));
+      } else {
+        bounds.right -= (bounds.right - bounds.left) * ChartUtils.DEFAULT_AXIS_SIZE;
+      }
+    }
+    return bounds;
+  }
+  getPlotlyDateFormat(formatter, columnType, formatPattern) {
+    var {
+      dh
+    } = this;
+    var tickformat = formatPattern == null ? undefined : formatPattern.replace('%', '%%').replace(/S{9}/g, '%9f').replace(/S{8}/g, '%8f').replace(/S{7}/g, '%7f').replace(/S{6}/g, '%6f').replace(/S{5}/g, '%5f').replace(/S{4}/g, '%4f').replace(/S{3}/g, '%3f').replace(/S{2}/g, '%2f').replace(/S{1}/g, '%1f').replace(/y{4}/g, '%Y').replace(/y{2}/g, '%y').replace(/M{4}/g, '%B').replace(/M{3}/g, '%b').replace(/M{2}/g, '%m').replace(/M{1}/g, '%-m').replace(/E{4,}/g, '%A').replace(/E{1,}/g, '%a').replace(/d{2}/g, '%d').replace(/([^%]|^)d{1}/g, '$1%-d').replace(/H{2}/g, '%H').replace(/h{2}/g, '%I').replace(/h{1}/g, '%-I').replace(/m{2}/g, '%M').replace(/s{2}/g, '%S').replace("'T'", 'T').replace(' z', ''); // timezone added as suffix if necessary
+
+    var ticksuffix;
+    var dataFormatter = formatter === null || formatter === void 0 ? void 0 : formatter.getColumnTypeFormatter(columnType);
+    if (dataFormatter != null && isDateTimeColumnFormatter(dataFormatter) && dataFormatter.dhTimeZone != null && dataFormatter.showTimeZone) {
+      ticksuffix = dh.i18n.DateTimeFormat.format(' z', new Date(), dataFormatter.dhTimeZone);
+    }
+    return {
+      tickformat,
+      ticksuffix,
+      automargin: true
+    };
+  }
+
+  /**
+   * Gets the plotly axis formatting information from the source passed in
+   * @param source The Source to get the formatter information from
+   * @param formatter The current formatter for formatting data
+   */
+  getPlotlyAxisFormat(source) {
+    var formatter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    var {
+      dh
+    } = this;
+    var {
+      axis,
+      columnType
+    } = source;
+    var {
+      formatPattern
+    } = axis;
+    var axisFormat = null;
+    if (TableUtils.isDateType(columnType)) {
+      axisFormat = this.getPlotlyDateFormat(formatter, columnType, formatPattern);
+      axisFormat = ChartUtils.addTickSpacing(axisFormat, axis, true);
+    } else if (TableUtils.isNumberType(columnType)) {
+      axisFormat = ChartUtils.getPlotlyNumberFormat(formatter, columnType, formatPattern);
+      axisFormat = ChartUtils.addTickSpacing(axisFormat, axis, false);
+    }
+    if (axis.formatType === dh.plot.AxisFormatType.CATEGORY) {
+      if (axisFormat) {
+        axisFormat.type = 'category';
+      } else {
+        axisFormat = {
+          type: 'category',
+          tickformat: undefined,
+          ticksuffix: undefined
+        };
+      }
+    }
+    return axisFormat;
+  }
+
+  /**
+   * Updates the axes positions and sizes in the layout object provided.
+   * If the axis did not exist in the layout previously, it is created and added.
+   * Any axis that no longer exists in axes is removed.
+   * With Downsampling enabled, will also update the range on the axis itself as appropriate
+   * @param layoutParam The layout object to update
+   * @param chartAxes The chart axes to update the layout with
+   * @param figureAxes All figure axes to update the layout with
+   * @param plotWidth The width of the plot to calculate the axis sizes for
+   * @param plotHeight The height of the plot to calculate the axis sizes for
+   * @param bounds The bounds for this set of axes
+   * @param axisRangeParser A function to retrieve the range parser for a given axis
+   */
+  updateLayoutAxes(layoutParam, chartAxes, figureAxes) {
+    var plotWidth = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+    var plotHeight = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
+    var bounds = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {
+      left: 0,
+      top: 0,
+      right: 1,
+      bottom: 1
+    };
+    var axisRangeParser = arguments.length > 6 ? arguments[6] : undefined;
+    var theme = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : ChartTheme;
+    var {
+      dh
+    } = this;
+    var xAxisSize = plotWidth > 0 ? Math.max(ChartUtils.MIN_AXIS_SIZE, Math.min(ChartUtils.AXIS_SIZE_PX / plotHeight, ChartUtils.MAX_AXIS_SIZE)) : ChartUtils.DEFAULT_AXIS_SIZE;
+    var yAxisSize = plotHeight > 0 ? Math.max(ChartUtils.MIN_AXIS_SIZE, Math.min(ChartUtils.AXIS_SIZE_PX / plotWidth, ChartUtils.MAX_AXIS_SIZE)) : ChartUtils.DEFAULT_AXIS_SIZE;
+    var layout = layoutParam;
+    var axisPositionMap = ChartUtils.groupArray(chartAxes, 'position');
+    var axisTypeMap = ChartUtils.groupArray(chartAxes, 'type');
+    var axisTypes = [...axisTypeMap.keys()];
+    var figureAxisTypeMap = ChartUtils.groupArray(figureAxes, 'type');
+    for (var j = 0; j < axisTypes.length; j += 1) {
+      var axisType = axisTypes[j];
+      var axisProperty = this.getAxisPropertyName(axisType);
+      if (axisProperty != null) {
+        var typeAxes = axisTypeMap.get(axisType);
+        var figureTypeAxes = figureAxisTypeMap.get(axisType);
+        var isYAxis = axisType === dh.plot.AxisType.Y;
+        var plotSize = isYAxis ? plotHeight : plotWidth;
+        assertNotNull(typeAxes);
+        assertNotNull(figureTypeAxes);
+        for (var chartAxisIndex = 0; chartAxisIndex < typeAxes.length; chartAxisIndex += 1) {
+          var _axis2 = typeAxes[chartAxisIndex];
+          var figureAxisIndex = figureTypeAxes.indexOf(_axis2);
+          var axisLayoutProperty = ChartUtils.getAxisLayoutProperty(axisProperty, figureAxisIndex);
+          if (layout[axisLayoutProperty] == null) {
+            layout[axisLayoutProperty] = this.makeLayoutAxis(axisType, theme);
+          }
+          var layoutAxis = layout[axisLayoutProperty];
+          if (layoutAxis != null) {
+            this.updateLayoutAxis(layoutAxis, _axis2, chartAxisIndex, axisPositionMap, xAxisSize, yAxisSize, bounds);
+            var {
+              range: _range,
+              autorange
+            } = layoutAxis;
+            if (axisRangeParser != null && _range !== undefined && (autorange === undefined || autorange === false)) {
+              var rangeParser = axisRangeParser(_axis2);
+              var [rangeStart, rangeEnd] = rangeParser(_range);
+              log.debug('Setting downsample range', plotSize, rangeStart, rangeEnd);
+              _axis2.range(plotSize, rangeStart, rangeEnd);
+            } else {
+              _axis2.range(plotSize);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Remove any axes from the layout param that no longer belong to any series
+   * @param layoutParam Layout object to remove stale axes from
+   * @param axes All axes in the figure
+   */
+  removeStaleAxes(layoutParam, axes) {
+    var layout = layoutParam;
+    var figureAxisTypeMap = ChartUtils.groupArray(axes, 'type');
+    var figureAxisTypes = [...figureAxisTypeMap.keys()];
+    for (var i = 0; i < figureAxisTypes.length; i += 1) {
+      var axisType = figureAxisTypes[i];
+      var typeAxes = figureAxisTypeMap.get(axisType);
+      assertNotNull(typeAxes);
+      var axisIndex = typeAxes.length;
+      // Delete any axes that may no longer exist
+      var axisProperty = this.getAxisPropertyName(axisType);
+      if (axisProperty != null) {
+        var axisLayoutProperty = ChartUtils.getAxisLayoutProperty(axisProperty, axisIndex);
+        while (layout[axisLayoutProperty] != null) {
+          delete layout[axisLayoutProperty];
+          axisIndex += 1;
+          axisLayoutProperty = ChartUtils.getAxisLayoutProperty(axisProperty, axisIndex);
+        }
+      }
+    }
+  }
+
+  /**
+   * Updates the layout axis object in place
+   * @param layoutAxisParam The plotly layout axis param
+   * @param axis The Iris Axis to update the plotly layout with
+   * @param axisIndex The type index for this axis
+   * @param axisPositionMap All the axes mapped by position
+   * @param axisSize The size of each axis in percent
+   * @param bounds The bounds of the axes domains
+   */
+  updateLayoutAxis(layoutAxisParam, axis, axisIndex, axisPositionMap, xAxisSize, yAxisSize, bounds) {
+    var _axis$label;
+    var {
+      dh
+    } = this;
+    var isYAxis = axis.type === dh.plot.AxisType.Y;
+    var axisSize = isYAxis ? yAxisSize : xAxisSize;
+    var layoutAxis = layoutAxisParam;
+    // Enterprise API returns null for empty axis labels
+    // Passing null title text to Plotly results in incorrect axis position, DH-9164
+    var label = (_axis$label = axis.label) !== null && _axis$label !== void 0 ? _axis$label : '';
+    if (layoutAxis.title !== undefined && typeof layoutAxis.title !== 'string') {
+      layoutAxis.title.text = label;
+    } else {
+      layoutAxis.title = {
+        text: label
+      };
+    }
+    if (axis.log) {
+      layoutAxis.type = 'log';
+    }
+    layoutAxis.side = this.getAxisSide(axis.position);
+    if (axisIndex > 0) {
+      var _this$getAxisProperty, _axisPositionMap$get2;
+      layoutAxis.overlaying = (_this$getAxisProperty = this.getAxisPropertyName(axis.type)) !== null && _this$getAxisProperty !== void 0 ? _this$getAxisProperty : undefined;
+      var positionAxes = (_axisPositionMap$get2 = axisPositionMap.get(axis.position)) !== null && _axisPositionMap$get2 !== void 0 ? _axisPositionMap$get2 : [];
+      var sideIndex = positionAxes.indexOf(axis);
+      if (sideIndex > 0) {
+        layoutAxis.anchor = 'free';
+        if (axis.position === dh.plot.AxisPosition.RIGHT) {
+          layoutAxis.position = bounds.right + (sideIndex - positionAxes.length + 1) * axisSize;
+        } else if (axis.position === dh.plot.AxisPosition.TOP) {
+          layoutAxis.position = bounds.top + (sideIndex - positionAxes.length + 1) * axisSize;
+        } else if (axis.position === dh.plot.AxisPosition.BOTTOM) {
+          layoutAxis.position = bounds.bottom + (positionAxes.length - sideIndex + 1) * axisSize;
+        } else if (axis.position === dh.plot.AxisPosition.LEFT) {
+          layoutAxis.position = bounds.left + (positionAxes.length - sideIndex + 1) * axisSize;
+        }
+      }
+    } else if (axis.type === dh.plot.AxisType.X) {
+      var leftAxes = axisPositionMap.get(dh.plot.AxisPosition.LEFT) || [];
+      var rightAxes = axisPositionMap.get(dh.plot.AxisPosition.RIGHT) || [];
+      var left = Math.max(bounds.left, bounds.left + (leftAxes.length - 1) * yAxisSize);
+      var right = Math.min(bounds.right - (rightAxes.length - 1) * yAxisSize, bounds.right);
+      layoutAxis.domain = [left, right];
+    } else if (axis.type === dh.plot.AxisType.Y) {
+      var bottomAxes = axisPositionMap.get(dh.plot.AxisPosition.BOTTOM) || [];
+      var topAxes = axisPositionMap.get(dh.plot.AxisPosition.TOP) || [];
+      var bottom = Math.max(bounds.bottom, bounds.bottom + (bottomAxes.length - 1) * xAxisSize);
+      var top = Math.min(bounds.top - (topAxes.length - 1) * xAxisSize, bounds.top);
+      layoutAxis.domain = [bottom, top];
+    }
+  }
+
+  /**
+   * Creates range break bounds for plotly from business days.
+   * For example a standard business week of ['MONDAY','TUESDAY','WEDNESDAY','THURSDAY','FRIDAY']
+   * will result in [[6,1]] meaning close on Saturday and open on Monday.
+   * If you remove Wednesday from the array, then you get two closures [[6, 1], [3, 4]]
+   *
+   * @param businessDays the days to display on the x-axis
+   */
+  createBoundsFromDays(businessDays) {
+    var businessDaysInt = businessDays.map(day => this.daysOfWeek.indexOf(day));
+    var nonBusinessDaysInt = this.daysOfWeek.filter(day => !businessDays.includes(day)).map(day => this.daysOfWeek.indexOf(day));
+    // These are the days when business reopens (e.g. Monday after a weekend)
+    var reopenDays = new Set();
+    nonBusinessDaysInt.forEach(closed => {
+      for (var i = closed + 1; i < closed + this.daysOfWeek.length; i += 1) {
+        var adjustedDay = i % this.daysOfWeek.length;
+        if (businessDaysInt.includes(adjustedDay)) {
+          reopenDays.add(adjustedDay);
+          break;
+        }
+      }
+    });
+    var boundsArray = [];
+    // For each reopen day, find the furthest previous closed day
+    reopenDays.forEach(open => {
+      for (var i = open - 1; i > open - this.daysOfWeek.length; i -= 1) {
+        var adjustedDay = i < 0 ? i + this.daysOfWeek.length : i;
+        if (businessDaysInt.includes(adjustedDay)) {
+          var closedDay = (adjustedDay + 1) % 7;
+          boundsArray.push([closedDay, open]);
+          break;
+        }
+      }
+    });
+    return boundsArray;
+  }
+
+  /**
+   * Creates an array of range breaks for all holidays.
+   *
+   * @param holidays an array of holidays
+   * @param calendarTimeZone the time zone for the business calendar
+   * @param formatterTimeZone the time zone for the formatter
+   */
+  createRangeBreakValuesFromHolidays(holidays, calendarTimeZone, formatterTimeZone) {
+    var fullHolidays = [];
+    var partialHolidays = [];
+    holidays.forEach(holiday => {
+      if (holiday.businessPeriods.length > 0) {
+        partialHolidays.push(...this.createPartialHoliday(holiday, calendarTimeZone, formatterTimeZone));
+      } else {
+        fullHolidays.push(this.createFullHoliday(holiday, calendarTimeZone, formatterTimeZone));
+      }
+    });
+    return [{
+      values: fullHolidays
+    }, ...partialHolidays];
+  }
+
+  /**
+   * Creates the range break value for a full holiday. A full holiday is day that has no business periods.
+   *
+   * @param holiday the full holiday
+   * @param calendarTimeZone the time zone for the business calendar
+   * @param formatterTimeZone the time zone for the formatter
+   */
+  createFullHoliday(holiday, calendarTimeZone, formatterTimeZone) {
+    return this.adjustDateForTimeZone("".concat(holiday.date.toString(), " 00:00:00.000000"), calendarTimeZone, formatterTimeZone);
+  }
+
+  /**
+   * Creates the range break for a partial holiday. A partial holiday is holiday with business periods
+   * that are different than the default business periods.
+   *
+   * @param holiday the partial holiday
+   * @param calendarTimeZone the time zone for the business calendar
+   * @param formatterTimeZone the time zone for the formatter
+   */
+  createPartialHoliday(holiday, calendarTimeZone, formatterTimeZone) {
+    // If a holiday has business periods {open1, close1} and {open2, close2}
+    // This will generate range breaks for:
+    // closed from 00:00 to open1
+    // closed from close1 to open2
+    // closed from close2 to 23:59:59.999999
+    var dateString = holiday.date.toString();
+    var closedPeriods = ['00:00'];
+    holiday.businessPeriods.forEach(period => {
+      closedPeriods.push(period.open);
+      closedPeriods.push(period.close);
+    });
+    // To go up to 23:59:59.999999, we calculate the dvalue using 24 - close
+    closedPeriods.push('24:00');
+    var rangeBreaks = [];
+    for (var i = 0; i < closedPeriods.length; i += 2) {
+      var startClose = closedPeriods[i];
+      var endClose = closedPeriods[i + 1];
+      // Skip over any periods where start and close are the same (zero hours)
+      if (startClose !== endClose) {
+        var values = [this.adjustDateForTimeZone("".concat(dateString, " ").concat(startClose, ":00.000000"), calendarTimeZone, formatterTimeZone)];
+        var dvalue = MILLIS_PER_HOUR * (ChartUtils.periodToDecimal(endClose) - ChartUtils.periodToDecimal(startClose));
+        rangeBreaks.push({
+          values,
+          dvalue
+        });
+      }
+    }
+    return rangeBreaks;
+  }
+
+  /**
+   * Adjusts a date string from the calendar time zone to the formatter time zone.
+   *
+   * @param dateString the date string
+   * @param calendarTimeZone the time zone for the business calendar
+   * @param formatterTimeZone the time zone for the formatter
+   */
+  adjustDateForTimeZone(dateString, calendarTimeZone, formatterTimeZone) {
+    if (formatterTimeZone && formatterTimeZone.standardOffset !== calendarTimeZone.standardOffset) {
+      return this.unwrapValue(this.wrapValue(dateString, BUSINESS_COLUMN_TYPE, calendarTimeZone), formatterTimeZone);
+    }
+    return dateString;
+  }
+
+  /**
+   * Creates the Figure settings from the Chart Builder settings
+   * This should be deprecated at some point, and have Chart Builder create the figure settings directly.
+   * This logic will still need to exist to translate existing charts, but could be part of a migration script
+   * to translate the data.
+   * Change when we decide to add more functionality to the Chart Builder.
+   * @param settings The chart builder settings
+   * @param settings.title The title for this figure
+   * @param settings.xAxis The name of the column to use for the x-axis
+   * @param settings.series The name of the columns to use for the series of this figure
+   * @param settings.type The plot style for this figure
+   */
+  makeFigureSettings(settings, table) {
+    var {
+      dh
+    } = this;
+    var {
+      series,
+      xAxis: settingsAxis,
+      type
+    } = settings;
+    var title = ChartUtils.titleFromSettings(settings);
+    var xAxis = {
+      formatType: "".concat(dh.plot.AxisFormatType.NUMBER),
+      type: "".concat(dh.plot.AxisType.X),
+      position: "".concat(dh.plot.AxisPosition.BOTTOM)
+    };
+    var yAxis = {
+      formatType: "".concat(dh.plot.AxisFormatType.NUMBER),
+      type: "".concat(dh.plot.AxisType.Y),
+      position: "".concat(dh.plot.AxisPosition.LEFT)
+    };
+    return {
+      charts: [{
+        chartType: "".concat(dh.plot.ChartType.XY),
+        axes: [xAxis, yAxis],
+        series: (series !== null && series !== void 0 ? series : []).map(name => ({
+          plotStyle: "".concat(type),
+          name,
+          dataSources: [{
+            type: "".concat(dh.plot.SourceType.X),
+            columnName: settingsAxis !== null && settingsAxis !== void 0 ? settingsAxis : '',
+            axis: xAxis,
+            table
+          }, {
+            type: "".concat(dh.plot.SourceType.Y),
+            columnName: name,
+            axis: yAxis,
+            table
+          }]
+        }))
+      }],
+      title
+    };
+  }
+
+  /**
+   * Unwraps a value provided from API to a value plotly can understand
+   * Eg. Unwraps DateWrapper, LongWrapper objects.
+   */
+  unwrapValue(value, timeZone) {
+    var {
+      dh
+    } = this;
+    if (value != null) {
+      if (isDateWrapper(value)) {
+        return dh.i18n.DateTimeFormat.format(ChartUtils.DATE_FORMAT, value, timeZone);
+      }
+      if (isLongWrapper(value)) {
+        return value.asNumber();
+      }
+    }
+    return value;
+  }
+
+  /**
+   *
+   * @param value The value to wrap up
+   * @param columnType The type of column this value is from
+   * @param timeZone The time zone if applicable
+   */
+  wrapValue(value, columnType) {
+    var timeZone = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+    var {
+      dh
+    } = this;
+    if (TableUtils.isDateType(columnType) && typeof value === 'string') {
+      // Need to limit the format to the actual length of the string range set in plotly
+      // Otherwise parse will fail
+      var text = value;
+      var format = ChartUtils.DATE_FORMAT.substr(0, value.length);
+      var date = dh.i18n.DateTimeFormat.parse(format, text);
+      if (!timeZone) {
+        return date;
+      }
+
+      // IDS-5994 Due to date parsing, time zone, and daylight savings shenanigans, we need
+      // to pass the actual offset with the time to have it parse correctly.
+      // However, the offset can change based on the date because of Daylight Savings
+      // So we end up parsing the date multiple times. And curse daylight savings.
+      var tzFormat = "".concat(format, " Z");
+      var estimatedOffset = dh.i18n.DateTimeFormat.format('Z', date, timeZone);
+      var estimatedDate = dh.i18n.DateTimeFormat.parse(tzFormat, "".concat(text, " ").concat(estimatedOffset));
+      var offset = dh.i18n.DateTimeFormat.format('Z', estimatedDate, timeZone);
+      return dh.i18n.DateTimeFormat.parse(tzFormat, "".concat(text, " ").concat(offset));
+    }
+    return value;
+  }
+  makeLayoutAxis(type) {
+    var theme = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ChartTheme;
+    var {
+      dh
+    } = this;
+    var axis = {
+      automargin: true,
+      gridcolor: theme.gridcolor,
+      linecolor: theme.linecolor,
+      rangeslider: {
+        visible: false
+      },
+      showline: true,
+      ticklen: 5,
+      // act as padding, can't find a tick padding
+      tickcolor: theme.paper_bgcolor,
+      // hide ticks as padding
+      tickfont: {
+        color: theme.zerolinecolor
+      },
+      title: {
+        font: {
+          color: theme.title_color
+        }
+      }
+    };
+    if (type === dh.plot.AxisType.X) {
+      Object.assign(axis, {
+        showgrid: true
+      });
+    } else if (type === dh.plot.AxisType.Y) {
+      Object.assign(axis, {
+        zerolinecolor: theme.zerolinecolor,
+        zerolinewidth: 2
+      });
+    }
+    return axis;
+  }
+  makeDefaultLayout() {
+    var theme = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ChartTheme;
+    var {
+      dh
+    } = this;
+    var layout = _objectSpread(_objectSpread({}, theme), {}, {
+      autosize: true,
+      colorway: ChartUtils.getColorwayFromTheme(theme),
+      font: {
+        family: "'Fira Sans', sans-serif",
+        color: theme.title_color
+      },
+      title: {
+        font: {
+          color: theme.title_color
+        },
+        yanchor: 'top',
+        pad: _objectSpread({}, ChartUtils.DEFAULT_TITLE_PADDING),
+        y: 1
+      },
+      legend: {
+        font: {
+          color: theme.title_color
+        }
+      },
+      margin: _objectSpread({}, ChartUtils.DEFAULT_MARGIN),
+      xaxis: this.makeLayoutAxis(dh.plot.AxisType.X, theme),
+      yaxis: this.makeLayoutAxis(dh.plot.AxisType.Y, theme),
+      polar: {
+        angularaxis: this.makeLayoutAxis(dh.plot.AxisType.SHAPE, theme),
+        radialaxis: this.makeLayoutAxis(dh.plot.AxisType.SHAPE, theme),
+        bgcolor: theme.plot_bgcolor
+      },
+      scene: {
+        xaxis: this.makeLayoutAxis(dh.plot.AxisType.X, theme),
+        yaxis: this.makeLayoutAxis(dh.plot.AxisType.Y, theme),
+        zaxis: this.makeLayoutAxis(dh.plot.AxisType.Z, theme)
+      }
+    });
+    layout.datarevision = 0;
+    return layout;
+  }
+
+  /**
+   * Hydrate settings from a JSONable object
+   * @param settings Dehydrated settings
+   */
+  hydrateSettings(settings) {
+    var {
+      dh
+    } = this;
+    return _objectSpread(_objectSpread({}, settings), {}, {
+      type: settings.type != null ? dh.plot.SeriesPlotStyle[settings.type] : undefined
+    });
+  }
+}
+_defineProperty(ChartUtils, "DEFAULT_AXIS_SIZE", 0.15);
+_defineProperty(ChartUtils, "MIN_AXIS_SIZE", 0.025);
+_defineProperty(ChartUtils, "MAX_AXIS_SIZE", 0.2);
+_defineProperty(ChartUtils, "AXIS_SIZE_PX", 75);
+_defineProperty(ChartUtils, "LEGEND_WIDTH_PX", 50);
+_defineProperty(ChartUtils, "MAX_LEGEND_SIZE", 0.25);
+_defineProperty(ChartUtils, "ORIENTATION", Object.freeze({
+  HORIZONTAL: 'h',
+  VERTICAL: 'v'
+}));
+_defineProperty(ChartUtils, "DATE_FORMAT", 'yyyy-MM-dd HH:mm:ss.SSSSSS');
+_defineProperty(ChartUtils, "DEFAULT_MARGIN", Object.freeze({
+  l: 60,
+  r: 50,
+  t: 30,
+  b: 60,
+  pad: 0
+}));
+_defineProperty(ChartUtils, "DEFAULT_TITLE_PADDING", Object.freeze({
+  t: 8
+}));
+_defineProperty(ChartUtils, "SUBTITLE_LINE_HEIGHT", 25);
+_defineProperty(ChartUtils, "DEFAULT_MARKER_SIZE", 6);
+_defineProperty(ChartUtils, "MODE_MARKERS", 'markers');
+_defineProperty(ChartUtils, "MODE_LINES", 'lines');
+export default ChartUtils;
+//# sourceMappingURL=ChartUtils.js.map