@deephaven/chart 0.78.3 → 0.78.8

package/dist/ChartUtils.js

@@ -293,6 +293,17 @@ class ChartUtils {
     return Number(values[0]) + Number(values[1]) / 60;
   }
 
+  /**
+   * Converts a decimal to a period. e.g 9.5 to '09:30'
+   *
+   * @param decimal the decimal value to
+   */
+  static decimalToPeriod(decimal) {
+    var hours = Math.floor(decimal);
+    var minutes = Math.round((decimal - hours) * 60);
+    return "".concat(hours.toString().padStart(2, '0'), ":").concat(minutes.toString().padStart(2, '0'));
+  }
+
   /**
    * Groups an array and returns a map
    * @param array The object to group
@@ -337,6 +348,48 @@ class ChartUtils {
     } = settings;
     return title;
   }
+  static getTimeZoneDiff(calendarTimeZone, formatterTimeZone) {
+    return formatterTimeZone ? (calendarTimeZone.standardOffset - formatterTimeZone.standardOffset) / 60 : 0;
+  }
+
+  /**
+   * Creates closed periods for a partial holiday.
+   *
+   * @param holidayPeriods the business periods for the holiday
+   * @param calendarPeriods the business periods for the calendar
+   * @returns an array of closed ranges for the partial holiday. Should be the ranges during the regular business hours that are _not_ specified by the holiday periods.
+   */
+  static createClosedRangesForPartialHoliday(holidayPeriods, calendarPeriods) {
+    // First restrict the periods to only those that are actual business periods.
+    var calendarRanges = calendarPeriods.map(period => [ChartUtils.periodToDecimal(period.open), ChartUtils.periodToDecimal(period.close)]);
+    calendarRanges.sort((a, b) => a[0] - b[0]);
+    if (calendarRanges.length === 0) {
+      calendarRanges.push([0, 24]);
+    }
+    var holidayRanges = holidayPeriods.map(period => [ChartUtils.periodToDecimal(period.open), ChartUtils.periodToDecimal(period.close)]);
+    holidayRanges.sort((a, b) => a[0] - b[0]);
+    var closedRanges = [];
+
+    // Separate index cursor for the holiday ranges
+    for (var c = 0; c < calendarRanges.length; c += 1) {
+      var calendarRange = calendarRanges[c];
+      var lastClose = calendarRange[0];
+      for (var h = 0; h < holidayRanges.length; h += 1) {
+        var holidayRange = holidayRanges[h];
+        if (holidayRange[1] > lastClose && holidayRange[0] < calendarRange[1]) {
+          if (holidayRange[0] > lastClose) {
+            closedRanges.push([lastClose, holidayRange[0]]);
+          }
+          // eslint-disable-next-line prefer-destructuring
+          lastClose = holidayRange[1];
+        }
+      }
+      if (lastClose < calendarRange[1]) {
+        closedRanges.push([lastClose, calendarRange[1]]);
+      }
+    }
+    return closedRanges;
+  }
   constructor(dh) {
     _defineProperty(this, "dh", void 0);
     _defineProperty(this, "daysOfWeek", void 0);
@@ -353,7 +406,6 @@ class ChartUtils {
    * @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,
@@ -372,74 +424,41 @@ class ChartUtils {
           sources
         } = series;
         var axisSources = sources.filter(source => source.axis);
-        var _loop = function _loop() {
+        for (var k = 0; k < axisSources.length; k += 1) {
           var source = axisSources[k];
           var {
-            axis
+            axis: _axis
           } = source;
           var {
             type: axisType
-          } = axis;
+          } = _axis;
           var typeAxes = axisTypeMap.get(axisType);
           assertNotNull(typeAxes);
-          var axisIndex = typeAxes.indexOf(axis);
-          var axisProperty = _this.getAxisPropertyName(axisType);
+          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);
+              var axisFormat = this.getPlotlyAxisFormat(source, formatter);
               if (axisFormat === null) {
                 axisFormats.set(axisLayoutProperty, nullFormat);
               } else {
                 axisFormats.set(axisLayoutProperty, axisFormat);
                 var {
                   businessCalendar
-                } = axis;
+                } = _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;
+                  axisFormat.rangebreaks = this.createRangeBreaksFromBusinessCalendar(businessCalendar, formatter);
                 }
                 if (axisFormats.size === _chart2.axes.length) {
-                  return {
-                    v: axisFormats
-                  };
+                  return axisFormats;
                 }
               }
             }
           }
-        };
-        for (var k = 0; k < axisSources.length; k += 1) {
-          var _ret = _loop();
-          if (typeof _ret === "object") return _ret.v;
         }
       }
     }
@@ -450,16 +469,19 @@ class ChartUtils {
    * 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
+   * @param allowWebGL If WebGL is allowedd
    */
   getPlotlyChartType(plotStyle, isBusinessTime) {
+    var allowWebGL = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     var {
       dh
     } = this;
     switch (plotStyle) {
       case dh.plot.SeriesPlotStyle.SCATTER:
       case dh.plot.SeriesPlotStyle.LINE:
-        // scattergl mode is more performant, but doesn't support the rangebreaks we need for businessTime calendars
-        return !isBusinessTime && IS_WEBGL_SUPPORTED ? 'scattergl' : 'scatter';
+        // scattergl mode is more performant (usually), but doesn't support the rangebreaks we need for businessTime calendars
+        // In some cases, WebGL is less performant (like in virtual desktop environments), so we also allow the option of the user explicitly disabling it even if it's supported
+        return !isBusinessTime && IS_WEBGL_SUPPORTED && allowWebGL ? 'scattergl' : 'scatter';
       case dh.plot.SeriesPlotStyle.BAR:
       case dh.plot.SeriesPlotStyle.STACKED_BAR:
         return 'bar';
@@ -625,6 +647,7 @@ class ChartUtils {
    */
   makeSeriesDataFromSeries(series, axisTypeMap, seriesVisibility) {
     var showLegend = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+    var allowWebGL = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
     var {
       name,
       isLinesVisible,
@@ -640,7 +663,7 @@ class ChartUtils {
       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 type = this.getChartType(plotStyle, isBusinessTime, allowWebGL);
     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);
@@ -653,16 +676,16 @@ class ChartUtils {
     for (var k = 0; k < sources.length; k += 1) {
       var source = sources[k];
       var {
-        axis: _axis,
+        axis: _axis2,
         type: sourceType
       } = source;
       var dataAttributeName = this.getPlotlyProperty(plotStyle, sourceType);
       set(seriesData, dataAttributeName, []);
-      var axisProperty = _axis != null ? this.getAxisPropertyName(_axis.type) : null;
+      var axisProperty = _axis2 != null ? this.getAxisPropertyName(_axis2.type) : null;
       if (axisProperty != null) {
-        var axes = axisTypeMap.get(_axis.type);
+        var axes = axisTypeMap.get(_axis2.type);
         if (axes) {
-          var axisIndex = axes.indexOf(_axis);
+          var axisIndex = axes.indexOf(_axis2);
           var axisIndexString = axisIndex > 0 ? "".concat(axisIndex + 1) : '';
           seriesData["".concat(axisProperty, "axis")] = "".concat(axisProperty).concat(axisIndexString);
         }
@@ -736,6 +759,7 @@ class ChartUtils {
     }
   }
   getChartType(plotStyle, isBusinessTime) {
+    var allowWebGL = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     var {
       dh
     } = this;
@@ -745,7 +769,7 @@ class ChartUtils {
         // 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 this.getPlotlyChartType(plotStyle, isBusinessTime, allowWebGL);
     }
   }
 
@@ -953,26 +977,26 @@ class ChartUtils {
         assertNotNull(typeAxes);
         assertNotNull(figureTypeAxes);
         for (var chartAxisIndex = 0; chartAxisIndex < typeAxes.length; chartAxisIndex += 1) {
-          var _axis2 = typeAxes[chartAxisIndex];
-          var figureAxisIndex = figureTypeAxes.indexOf(_axis2);
+          var _axis3 = typeAxes[chartAxisIndex];
+          var figureAxisIndex = figureTypeAxes.indexOf(_axis3);
           var axisLayoutProperty = ChartUtils.getAxisLayoutProperty(axisProperty, figureAxisIndex);
           if (layout[axisLayoutProperty] == null) {
             layout[axisLayoutProperty] = {};
           }
           var layoutAxis = layout[axisLayoutProperty];
           if (layoutAxis != null) {
-            this.updateLayoutAxis(layoutAxis, _axis2, chartAxisIndex, axisPositionMap, xAxisSize, yAxisSize, bounds);
+            this.updateLayoutAxis(layoutAxis, _axis3, chartAxisIndex, axisPositionMap, xAxisSize, yAxisSize, bounds);
             var {
               range: _range,
               autorange
             } = layoutAxis;
             if (axisRangeParser != null && _range !== undefined && (autorange === undefined || autorange === false)) {
-              var rangeParser = axisRangeParser(_axis2);
+              var rangeParser = axisRangeParser(_axis3);
               var [rangeStart, rangeEnd] = rangeParser(_range);
               log.debug('Setting downsample range', plotSize, rangeStart, rangeEnd);
-              _axis2.range(plotSize, rangeStart, rangeEnd);
+              _axis3.range(plotSize, rangeStart, rangeEnd);
             } else {
-              _axis2.range(plotSize);
+              _axis3.range(plotSize);
             }
           }
         }
@@ -1070,6 +1094,45 @@ class ChartUtils {
     }
   }
 
+  /**
+   * Creates the bounds for the periods specified.
+   * For example, if you pass in [['09:00', '17:00']], it will return [17, 9] (closing at 5pm, opening at 9am the next day)
+   * If you pass [['09:00', '12:00'], ['13:00', '17:00']], it will return [12, 13] (closing at noon, opening at 1pm) and [17, 9] (closing at 5pm, opening at 9am the next day)
+   * @param periods Periods to map
+   * @param timeZoneDiff Time zone difference in hours
+   * @returns Bounds for the periods in plotly format
+   */
+  // eslint-disable-next-line class-methods-use-this
+  createBoundsFromPeriods(periods) {
+    var timeZoneDiff = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    if (periods.length === 0) {
+      return [];
+    }
+    var numberPeriods = periods.map(period => [(ChartUtils.periodToDecimal(period.open) + timeZoneDiff) % 24, (ChartUtils.periodToDecimal(period.close) + timeZoneDiff) % 24]).sort((a, b) => a[0] - b[0]);
+    var bounds = [];
+    for (var i = 0; i < numberPeriods.length; i += 1) {
+      var period = numberPeriods[i];
+      var nextPeriod = numberPeriods[(i + 1) % numberPeriods.length];
+      bounds.push([period[1], nextPeriod[0]]);
+    }
+    return bounds;
+  }
+
+  /**
+   * Creates range breaks for plotly from business periods.
+   * @param periods Business periods to create the breaks for
+   * @param timeZoneDiff Time zone difference in hours
+   * @returns Plotly range breaks for the business periods
+   */
+  createBreaksFromPeriods(periods) {
+    var timeZoneDiff = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    var bounds = this.createBoundsFromPeriods(periods, timeZoneDiff);
+    return bounds.map(bound => ({
+      pattern: 'hour',
+      bounds: bound
+    }));
+  }
+
   /**
    * Creates range break bounds for plotly from business days.
    * For example a standard business week of ['MONDAY','TUESDAY','WEDNESDAY','THURSDAY','FRIDAY']
@@ -1079,47 +1142,91 @@ class ChartUtils {
    * @param businessDays the days to display on the x-axis
    */
   createBoundsFromDays(businessDays) {
+    var weekLength = this.daysOfWeek.length;
+    // No breaks if all days are business days
+    if (businessDays.length === weekLength) {
+      return [];
+    }
     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 businessDaysSet = new Set(businessDaysInt);
+
+    // These are the days when business is closed (e.g. Saturday to start the weekend)
+    var closedDays = new Set();
+    for (var i = 0; i < weekLength; i += 1) {
+      if (!businessDaysSet.has(i) && businessDaysSet.has((i - 1 + weekLength) % weekLength)) {
+        closedDays.add(i);
       }
-    });
+    }
     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;
+    // For each close day, find the next open day
+    closedDays.forEach(closedDay => {
+      for (var _i = 0; _i < weekLength; _i += 1) {
+        var adjustedDay = (closedDay + _i) % weekLength;
+        if (businessDaysSet.has(adjustedDay)) {
+          boundsArray.push([closedDay, adjustedDay]);
+          return;
         }
       }
+      throw new Error("Unable to find open day for closed day ".concat(closedDay, ", businessDays: ").concat(businessDays));
     });
     return boundsArray;
   }
 
+  /**
+   * Breaks in plotly for business days
+   * @param businessDays Business days to create the breaks for
+   * @returns Plotly range breaks for the business days
+   */
+  createBreaksFromDays(businessDays) {
+    var bounds = this.createBoundsFromDays(businessDays);
+    return bounds.map(bound => ({
+      pattern: 'day of week',
+      bounds: bound
+    }));
+  }
+
+  /**
+   * Creates range breaks for plotly from a business calendar.
+   * @param businessCalendar Calendar to create the breaks from
+   * @param formatter Formatter to use for time zones
+   * @returns Plotly Rangebreaks for the business calendar
+   */
+  createRangeBreaksFromBusinessCalendar(businessCalendar, formatter) {
+    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 = ChartUtils.getTimeZoneDiff(calendarTimeZone, formatterTimeZone);
+    if (holidays.length > 0) {
+      rangebreaks.push(...this.createRangeBreakValuesFromHolidays(holidays, calendarTimeZone, formatterTimeZone, businessCalendar));
+    }
+    rangebreaks.push(...this.createBreaksFromPeriods(businessPeriods, timeZoneDiff));
+    rangebreaks.push(...this.createBreaksFromDays(businessDays));
+    return rangebreaks;
+  }
+
   /**
    * 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
+   * @param calendar the calendar the holidays are from
    */
-  createRangeBreakValuesFromHolidays(holidays, calendarTimeZone, formatterTimeZone) {
+  createRangeBreakValuesFromHolidays(holidays, calendarTimeZone, formatterTimeZone, calendar) {
     var fullHolidays = [];
     var partialHolidays = [];
     holidays.forEach(holiday => {
       if (holiday.businessPeriods.length > 0) {
-        partialHolidays.push(...this.createPartialHoliday(holiday, calendarTimeZone, formatterTimeZone));
+        partialHolidays.push(...this.createPartialHoliday(holiday, calendarTimeZone, formatterTimeZone, calendar));
       } else {
         fullHolidays.push(this.createFullHoliday(holiday, calendarTimeZone, formatterTimeZone));
       }
@@ -1147,29 +1254,33 @@ class ChartUtils {
    * @param holiday the partial holiday
    * @param calendarTimeZone the time zone for the business calendar
    * @param formatterTimeZone the time zone for the formatter
+   * @param calendar the calendar the holiday is from. Used to check against the default business periods to ensure this holiday needs to be specified
+   *
+   * @returns an array of range breaks for the partial holiday
    */
-  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
+  createPartialHoliday(holiday, calendarTimeZone, formatterTimeZone, calendar) {
+    var _calendar$businessPer;
+    if (holiday.businessPeriods.length === 0) {
+      return [];
+    }
     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');
+
+    // First check that the holiday is on a business day. If it's not, we can ignore it
+    if (calendar) {
+      var dayOfWeek = new Date(dateString).getDay();
+      var isBusinessDay = calendar.businessDays.includes(this.daysOfWeek[dayOfWeek]);
+      if (!isBusinessDay) {
+        return [];
+      }
+    }
+    var closedPeriods = ChartUtils.createClosedRangesForPartialHoliday(holiday.businessPeriods, (_calendar$businessPer = calendar === null || calendar === void 0 ? void 0 : calendar.businessPeriods) !== null && _calendar$businessPer !== void 0 ? _calendar$businessPer : []);
     var rangeBreaks = [];
-    for (var i = 0; i < closedPeriods.length; i += 2) {
-      var startClose = closedPeriods[i];
-      var endClose = closedPeriods[i + 1];
+    for (var i = 0; i < closedPeriods.length; i += 1) {
+      var [closeStart, closeEnd] = closedPeriods[i];
       // 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));
+      if (closeStart !== closeEnd) {
+        var values = [this.adjustDateForTimeZone("".concat(dateString, " ").concat(ChartUtils.decimalToPeriod(closeStart), ":00.000000"), calendarTimeZone, formatterTimeZone)];
+        var dvalue = MILLIS_PER_HOUR * (closeEnd - closeStart);
         rangeBreaks.push({
           values,
           dvalue