@kepler.gl/utils 3.1.0-alpha.1 → 3.1.0-alpha.3

package/dist/plot.js

@@ -0,0 +1,615 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.adjustValueToAnimationWindow = adjustValueToAnimationWindow;
+exports.binByTime = binByTime;
+exports.getAggregationOptiosnBasedOnField = void 0;
+exports.getBinThresholds = getBinThresholds;
+exports.getChartTitle = getChartTitle;
+exports.getDefaultPlotType = getDefaultPlotType;
+exports.getFilterDataFunc = getFilterDataFunc;
+exports.getLineChart = getLineChart;
+exports.getPctChange = getPctChange;
+exports.getRangeFilterBins = getRangeFilterBins;
+exports.getTimeBins = getTimeBins;
+exports.getValueAggrFunc = void 0;
+exports.histogramFromDomain = histogramFromDomain;
+exports.histogramFromThreshold = histogramFromThreshold;
+exports.histogramFromValues = histogramFromValues;
+exports.isPercentField = isPercentField;
+exports.normalizeValue = normalizeValue;
+exports.runGpuFilterForPlot = runGpuFilterForPlot;
+exports.snapToMarks = snapToMarks;
+exports.splitSeries = splitSeries;
+exports.updateAggregationByField = updateAggregationByField;
+exports.updateRangeFilterPlotType = updateRangeFilterPlotType;
+exports.updateTimeFilterPlotType = updateTimeFilterPlotType;
+exports.validBin = validBin;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _d3Array = require("d3-array");
+var _lodash = _interopRequireDefault(require("lodash.isequal"));
+var _time = require("./time");
+var _moment = _interopRequireDefault(require("moment"));
+var _commonUtils = require("@kepler.gl/common-utils");
+var _constants = require("@kepler.gl/constants");
+var _dataUtils = require("./data-utils");
+var _aggregation = require("./aggregation");
+var _strings = require("./strings");
+var _format = require("./format");
+var _colorUtils = require("./color-utils");
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+// TODO kepler-table module isn't accessible from utils. Add compatible interface to types
+
+/**
+ *
+ * @param thresholds
+ * @param values
+ * @param indexes
+ */
+function histogramFromThreshold(thresholds, values, valueAccessor) {
+  var filterEmptyBins = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+  var getBins = (0, _d3Array.histogram)().domain([thresholds[0], thresholds[thresholds.length - 1]]).thresholds(thresholds);
+  if (valueAccessor) {
+    getBins.value(valueAccessor);
+  }
+
+  // @ts-ignore
+  var bins = getBins(values).map(function (bin) {
+    return {
+      count: bin.length,
+      indexes: bin,
+      x0: bin.x0,
+      x1: bin.x1
+    };
+  });
+
+  // d3-histogram ignores threshold values outside the domain
+  // The first bin.x0 is always equal to the minimum domain value, and the last bin.x1 is always equal to the maximum domain value.
+
+  // bins[0].x0 = thresholds[0];
+  // bins[bins.length - 1].x1 = thresholds[thresholds.length - 1];
+
+  // @ts-ignore
+  return filterEmptyBins ? bins.filter(function (b) {
+    return b.count > 0;
+  }) : bins;
+}
+
+/**
+ *
+ * @param values
+ * @param numBins
+ * @param valueAccessor
+ */
+function histogramFromValues(values, numBins, valueAccessor) {
+  var getBins = (0, _d3Array.histogram)().thresholds(numBins);
+  if (valueAccessor) {
+    getBins.value(valueAccessor);
+  }
+
+  // @ts-ignore d3-array types doesn't match
+  return getBins(values).map(function (bin) {
+    return {
+      count: bin.length,
+      indexes: bin,
+      x0: bin.x0,
+      x1: bin.x1
+    };
+  }).filter(function (b) {
+    var x0 = b.x0,
+      x1 = b.x1;
+    return (0, _dataUtils.isNumber)(x0) && (0, _dataUtils.isNumber)(x1);
+  });
+}
+
+/**
+ *
+ * @param domain
+ * @param values
+ * @param numBins
+ * @param valueAccessor
+ */
+function histogramFromDomain(domain, values, numBins, valueAccessor) {
+  var getBins = (0, _d3Array.histogram)().thresholds((0, _d3Array.ticks)(domain[0], domain[1], numBins)).domain(domain);
+  if (valueAccessor) {
+    getBins.value(valueAccessor);
+  }
+
+  // @ts-ignore d3-array types doesn't match
+  return getBins(values).map(function (bin) {
+    return {
+      count: bin.length,
+      indexes: bin,
+      x0: bin.x0,
+      x1: bin.x1
+    };
+  });
+}
+
+/**
+ * @param filter
+ * @param datasets
+ * @param interval
+ */
+function getTimeBins(filter, datasets, interval) {
+  var bins = filter.timeBins || {};
+  filter.dataId.forEach(function (dataId, dataIdIdx) {
+    // reuse bins if filterData did not change
+    if (bins[dataId] && bins[dataId][interval]) {
+      return;
+    }
+    var dataset = datasets[dataId];
+
+    // do not apply current filter
+    var indexes = runGpuFilterForPlot(dataset, filter);
+    bins = _objectSpread(_objectSpread({}, bins), {}, (0, _defineProperty2["default"])({}, dataId, _objectSpread(_objectSpread({}, bins[dataId]), {}, (0, _defineProperty2["default"])({}, interval, binByTime(indexes, dataset, interval, filter)))));
+  });
+  return bins;
+}
+function binByTime(indexes, dataset, interval, filter) {
+  // gpuFilters need to be apply to filteredIndex
+  var mappedValue = (0, _time.getFilterMappedValue)(dataset, filter);
+  if (!mappedValue) {
+    return null;
+  }
+  var intervalBins = getBinThresholds(interval, filter.domain);
+  var valueAccessor = function valueAccessor(idx) {
+    return mappedValue[idx];
+  };
+  var bins = histogramFromThreshold(intervalBins, indexes, valueAccessor);
+  return bins;
+}
+function getBinThresholds(interval, domain) {
+  var timeInterval = (0, _time.intervalToFunction)(interval);
+  var _domain = (0, _slicedToArray2["default"])(domain, 2),
+    t0 = _domain[0],
+    t1 = _domain[1];
+  var floor = timeInterval.floor(t0).getTime();
+  var ceiling = timeInterval.ceil(t1).getTime();
+  if (!timeInterval) {
+    // if time interval is not defined
+    // this should not happen
+    return [t0, t0 + _constants.durationDay];
+  }
+  var binThresholds = timeInterval.range(floor, ceiling + 1).map(function (t) {
+    return _moment["default"].utc(t).valueOf();
+  });
+  var lastStep = binThresholds[binThresholds.length - 1];
+  if (lastStep === t1) {
+    // when last step equal to domain max, add one more step
+    binThresholds.push(_moment["default"].utc(timeInterval.offset(lastStep)).valueOf());
+  }
+  return binThresholds;
+}
+
+/**
+ * Run GPU filter on current filter result to generate indexes for ploting chart
+ * Skip ruuning for the same field
+ * @param dataset
+ * @param filter
+ */
+function runGpuFilterForPlot(dataset, filter) {
+  var skipIndexes = getSkipIndexes(dataset, filter);
+  var _dataset$gpuFilter = dataset.gpuFilter,
+    filterValueUpdateTriggers = _dataset$gpuFilter.filterValueUpdateTriggers,
+    filterRange = _dataset$gpuFilter.filterRange,
+    filterValueAccessor = _dataset$gpuFilter.filterValueAccessor,
+    filteredIndex = dataset.filteredIndex;
+  var getFilterValue = filterValueAccessor(dataset.dataContainer)();
+  var allChannels = Object.keys(filterValueUpdateTriggers).map(function (_, i) {
+    return i;
+  }).filter(function (i) {
+    return Object.values(filterValueUpdateTriggers)[i];
+  });
+  var skipAll = !allChannels.filter(function (i) {
+    return !skipIndexes.includes(i);
+  }).length;
+  if (skipAll) {
+    return filteredIndex;
+  }
+  var filterData = getFilterDataFunc(filterRange, getFilterValue, dataset.dataContainer, skipIndexes);
+  return filteredIndex.filter(filterData);
+}
+function getSkipIndexes(dataset, filter) {
+  // array of gpu filter names
+  if (!filter) {
+    return [];
+  }
+  var gpuFilters = Object.values(dataset.gpuFilter.filterValueUpdateTriggers);
+  var valueIndex = filter.dataId.findIndex(function (id) {
+    return id === dataset.id;
+  });
+  var filterColumn = filter.name[valueIndex];
+  return gpuFilters.reduce(function (accu, item, idx) {
+    if (item && filterColumn === item.name) {
+      accu.push(idx);
+    }
+    return accu;
+  }, []);
+}
+function getFilterDataFunc(filterRange, getFilterValue, dataContainer, skips) {
+  return function (index) {
+    return getFilterValue({
+      index: index
+    }).every(function (val, i) {
+      return skips.includes(i) || val >= filterRange[i][0] && val <= filterRange[i][1];
+    });
+  };
+}
+function validBin(b) {
+  return b.x0 !== undefined && b.x1 !== undefined;
+}
+
+/**
+ * Use in slider, given a number and an array of numbers, return the nears number from the array.
+ * Takes a value, timesteps and return the actual step.
+ * @param value
+ * @param marks
+ */
+function snapToMarks(value, marks) {
+  // always use bin x0
+  if (!marks.length) {
+    // @ts-expect-error looking at the usage null return value isn't expected and requires extra handling in a lot of places
+    return null;
+  }
+  var i = (0, _d3Array.bisectLeft)(marks, value);
+  if (i === 0) {
+    return marks[i];
+  } else if (i === marks.length) {
+    return marks[i - 1];
+  }
+  var idx = marks[i] - value < value - marks[i - 1] ? i : i - 1;
+  return marks[idx];
+}
+function normalizeValue(val, minValue, step, marks) {
+  if (marks && marks.length) {
+    return snapToMarks(val, marks);
+  }
+  return (0, _dataUtils.roundValToStep)(minValue, step, val);
+}
+function isPercentField(field) {
+  return field.metadata && field.metadata.numerator && field.metadata.denominator;
+}
+function updateAggregationByField(field, aggregation) {
+  // shouldn't apply sum to percent fiele type
+  // default aggregation is average
+  return field && isPercentField(field) ? _constants.AGGREGATION_TYPES.average : aggregation || _constants.AGGREGATION_TYPES.average;
+}
+var getAgregationType = function getAgregationType(field, aggregation) {
+  if (isPercentField(field)) {
+    return 'mean_of_percent';
+  }
+  return aggregation;
+};
+var getAggregationAccessor = function getAggregationAccessor(field, dataContainer, fields) {
+  if (isPercentField(field)) {
+    var numeratorIdx = fields.findIndex(function (f) {
+      return f.name === field.metadata.numerator;
+    });
+    var denominatorIdx = fields.findIndex(function (f) {
+      return f.name === field.metadata.denominator;
+    });
+    return {
+      getNumerator: function getNumerator(i) {
+        return dataContainer.valueAt(i, numeratorIdx);
+      },
+      getDenominator: function getDenominator(i) {
+        return dataContainer.valueAt(i, denominatorIdx);
+      }
+    };
+  }
+  return function (i) {
+    return field.valueAccessor({
+      index: i
+    });
+  };
+};
+var getValueAggrFunc = exports.getValueAggrFunc = function getValueAggrFunc(field, aggregation, dataset) {
+  var dataContainer = dataset.dataContainer,
+    fields = dataset.fields;
+
+  // The passed-in field might not have all the fields set (e.g. valueAccessor)
+  var datasetField = fields.find(function (f) {
+    return field && (f.name === field || f.name === field.name);
+  });
+  return datasetField && aggregation ? function (bin) {
+    return (0, _aggregation.aggregate)(bin.indexes, getAgregationType(datasetField, aggregation),
+    // @ts-expect-error can return {getNumerator, getDenominator}
+    getAggregationAccessor(datasetField, dataContainer, fields));
+  } : function (bin) {
+    return bin.count;
+  };
+};
+var getAggregationOptiosnBasedOnField = exports.getAggregationOptiosnBasedOnField = function getAggregationOptiosnBasedOnField(field) {
+  if (isPercentField(field)) {
+    // don't show sum
+    return _constants.TIME_AGGREGATION.filter(function (_ref) {
+      var id = _ref.id;
+      return id !== _constants.AGGREGATION_TYPES.sum;
+    });
+  }
+  return _constants.TIME_AGGREGATION;
+};
+function getDelta(bins, y, interval) {
+  // if (WOW[interval]) return getWow(bins, y, interval);
+  var lastBin = bins[bins.length - 1];
+  return {
+    delta: 'last',
+    pct: lastBin ? getPctChange(y, lastBin.y) : null
+  };
+}
+function getPctChange(y, y0) {
+  if (Number.isFinite(y) && Number.isFinite(y0) && y0 !== 0) {
+    return (y - y0) / y0;
+  }
+  return null;
+}
+
+/**
+ *
+ * @param datasets
+ * @param filter
+ */
+function getLineChart(datasets, filter) {
+  var _timeBins;
+  var dataId = filter.dataId,
+    yAxis = filter.yAxis,
+    plotType = filter.plotType,
+    lineChart = filter.lineChart;
+  var aggregation = plotType.aggregation,
+    interval = plotType.interval;
+  var seriesDataId = dataId[0];
+  var bins = (_timeBins = filter.timeBins) === null || _timeBins === void 0 || (_timeBins = _timeBins[seriesDataId]) === null || _timeBins === void 0 ? void 0 : _timeBins[interval];
+  if (lineChart && lineChart.aggregation === aggregation && lineChart.interval === interval && lineChart.yAxis === (yAxis === null || yAxis === void 0 ? void 0 : yAxis.name) &&
+  // we need to make sure we validate bins because of cross filter data changes
+  (0, _lodash["default"])(bins, lineChart === null || lineChart === void 0 ? void 0 : lineChart.bins)) {
+    // don't update lineChart if plotType hasn't change
+    return lineChart;
+  }
+  var dataset = datasets[seriesDataId];
+  var getYValue = getValueAggrFunc(yAxis, aggregation, dataset);
+  var init = [];
+  var series = (bins || []).reduce(function (accu, bin, i) {
+    var y = getYValue(bin);
+    var delta = getDelta(accu, y, interval);
+    accu.push(_objectSpread({
+      x: bin.x0,
+      y: y
+    }, delta));
+    return accu;
+  }, init);
+  var yDomain = (0, _d3Array.extent)(series, function (d) {
+    return d.y;
+  });
+  var xDomain = bins ? [bins[0].x0, bins[bins.length - 1].x1] : [];
+
+  // treat missing data as another series
+  var split = splitSeries(series);
+  var aggrName = _aggregation.AGGREGATION_NAME[aggregation];
+  return {
+    // @ts-ignore
+    yDomain: yDomain,
+    // @ts-ignore
+    xDomain: xDomain,
+    interval: interval,
+    aggregation: aggregation,
+    // @ts-ignore
+    series: split,
+    title: "".concat(aggrName, ' of ').concat(yAxis ? yAxis.name : 'Count'),
+    fieldType: yAxis ? yAxis.type : 'integer',
+    yAxis: yAxis ? yAxis.name : null,
+    allTime: {
+      title: "All Time Average",
+      value: (0, _aggregation.aggregate)(series, _constants.AGGREGATION_TYPES.average, function (d) {
+        return d.y;
+      })
+    },
+    // @ts-expect-error bins is Bins[], not a Bins map. Refactor to use correct types.
+    bins: bins
+  };
+}
+
+// split into multiple series when see missing data
+function splitSeries(series) {
+  var lines = [];
+  var temp = [];
+  for (var i = 0; i < series.length; i++) {
+    var d = series[i];
+    if (!(0, _commonUtils.notNullorUndefined)(d.y) && temp.length) {
+      // ends temp
+      lines.push(temp);
+      temp = [];
+    } else if ((0, _commonUtils.notNullorUndefined)(d.y)) {
+      temp.push(d);
+    }
+    if (i === series.length - 1 && temp.length) {
+      lines.push(temp);
+    }
+  }
+  var markers = lines.length > 1 ? series.filter(function (d) {
+    return (0, _commonUtils.notNullorUndefined)(d.y);
+  }) : [];
+  return {
+    lines: lines,
+    markers: markers
+  };
+}
+function adjustValueToAnimationWindow(state, filter) {
+  var plotType = filter.plotType,
+    _filter$value = (0, _slicedToArray2["default"])(filter.value, 2),
+    value0 = _filter$value[0],
+    value1 = _filter$value[1],
+    animationWindow = filter.animationWindow;
+  var interval = plotType.interval || (0, _time.getInitialInterval)(filter, state.datasets);
+  var bins = getTimeBins(filter, state.datasets, interval);
+  var datasetBins = bins && Object.keys(bins).length && Object.values(bins)[0][interval];
+  var thresholds = (datasetBins || []).map(function (b) {
+    return b.x0;
+  });
+  var val0 = value0;
+  var val1 = value1;
+  var idx;
+  if (animationWindow === _constants.ANIMATION_WINDOW.interval) {
+    val0 = snapToMarks(value1, thresholds);
+    idx = thresholds.indexOf(val0);
+    val1 = idx > -1 ? datasetBins[idx].x1 : NaN;
+  } else {
+    // fit current value to window
+    val0 = snapToMarks(value0, thresholds);
+    val1 = snapToMarks(value1, thresholds);
+    if (val0 === val1) {
+      idx = thresholds.indexOf(val0);
+      if (idx === thresholds.length - 1) {
+        val0 = thresholds[idx - 1];
+      } else {
+        val1 = thresholds[idx + 1];
+      }
+    }
+  }
+  var updatedFilter = _objectSpread(_objectSpread({}, filter), {}, {
+    plotType: _objectSpread(_objectSpread({}, filter.plotType), {}, {
+      interval: interval
+    }),
+    timeBins: bins,
+    value: [val0, val1]
+  });
+  return updatedFilter;
+}
+
+/**
+ * Create or update colors for a filter plot
+ * @param filter
+ * @param datasets
+ * @param oldColorsByDataId
+ */
+function getFilterPlotColorsByDataId(filter, datasets, oldColorsByDataId) {
+  var colorsByDataId = oldColorsByDataId || {};
+  var _iterator = _createForOfIteratorHelper(filter.dataId),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var dataId = _step.value;
+      if (!colorsByDataId[dataId] && datasets[dataId]) {
+        colorsByDataId = _objectSpread(_objectSpread({}, colorsByDataId), {}, (0, _defineProperty2["default"])({}, dataId, (0, _colorUtils.rgbToHex)(datasets[dataId].color)));
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return colorsByDataId;
+}
+
+/**
+ *
+ * @param filter
+ * @param plotType
+ * @param datasets
+ * @param dataId
+ */
+function updateTimeFilterPlotType(filter, plotType, datasets, dataId) {
+  var nextFilter = filter;
+  var nextPlotType = plotType;
+  if ((0, _typeof2["default"])(nextPlotType) !== 'object' || !nextPlotType.aggregation || !nextPlotType.interval) {
+    nextPlotType = getDefaultPlotType(filter, datasets);
+  }
+  if (filter.dataId.length > 1) {
+    nextPlotType = _objectSpread(_objectSpread({}, nextPlotType), {}, {
+      colorsByDataId: getFilterPlotColorsByDataId(filter, datasets, nextPlotType.colorsByDataId)
+    });
+  }
+  nextFilter = _objectSpread(_objectSpread({}, nextFilter), {}, {
+    plotType: nextPlotType
+  });
+  var bins = getTimeBins(nextFilter, datasets, nextPlotType.interval);
+  nextFilter = _objectSpread(_objectSpread({}, nextFilter), {}, {
+    timeBins: bins
+  });
+  if (plotType.type === _constants.PLOT_TYPES.histogram) {
+    // Histogram is calculated and memoized in the chart itself
+  } else if (plotType.type === _constants.PLOT_TYPES.lineChart) {
+    // we should be able to move this into its own component so react will do the shallow comparison for us.
+    nextFilter = _objectSpread(_objectSpread({}, nextFilter), {}, {
+      lineChart: getLineChart(datasets, nextFilter)
+    });
+  }
+  return nextFilter;
+}
+function getRangeFilterBins(filter, datasets, numBins) {
+  var domain = filter.domain;
+  if (!filter.dataId) return null;
+  return filter.dataId.reduce(function (acc, dataId, datasetIdx) {
+    var _filter$bins;
+    if ((_filter$bins = filter.bins) !== null && _filter$bins !== void 0 && _filter$bins[dataId]) {
+      // don't recalculate bins
+      acc[dataId] = filter.bins[dataId];
+      return acc;
+    }
+    var fieldName = filter.name[datasetIdx];
+    if (dataId && fieldName) {
+      var dataset = datasets[dataId];
+      var field = dataset === null || dataset === void 0 ? void 0 : dataset.getColumnField(fieldName);
+      if (dataset && field) {
+        var indexes = runGpuFilterForPlot(dataset, filter);
+        var valueAccessor = function valueAccessor(index) {
+          return field.valueAccessor({
+            index: index
+          });
+        };
+        acc[dataId] = histogramFromDomain(domain, indexes, numBins, valueAccessor);
+      }
+    }
+    return acc;
+  }, {});
+}
+function updateRangeFilterPlotType(filter, plotType, datasets, dataId) {
+  var nextFilter = _objectSpread(_objectSpread({}, filter), {}, {
+    plotType: plotType
+  });
+
+  // if (dataId) {
+  //   // clear bins
+  //   nextFilter = {
+  //     ...nextFilter,
+  //     bins: {
+  //       ...nextFilter.bins,
+  //       [dataId]: null
+  //     }
+  //   };
+  // }
+
+  return _objectSpread(_objectSpread({}, filter), {}, {
+    plotType: plotType,
+    bins: getRangeFilterBins(nextFilter, datasets, _constants.BINS)
+  });
+}
+function getChartTitle(yAxis, plotType) {
+  var yAxisName = yAxis === null || yAxis === void 0 ? void 0 : yAxis.displayName;
+  var aggregation = plotType.aggregation;
+  if (yAxisName) {
+    return (0, _strings.capitalizeFirstLetter)("".concat(aggregation, " ").concat(yAxisName, " over Time"));
+  }
+  return "Count of Rows over Time";
+}
+function getDefaultPlotType(filter, datasets) {
+  var interval = (0, _time.getInitialInterval)(filter, datasets);
+  var defaultTimeFormat = (0, _format.getDefaultTimeFormat)(interval);
+  return {
+    interval: interval,
+    defaultTimeFormat: defaultTimeFormat,
+    type: _constants.PLOT_TYPES.histogram,
+    aggregation: _constants.AGGREGATION_TYPES.sum
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_d3Array","require","_lodash","_interopRequireDefault","_time","_moment","_commonUtils","_constants","_dataUtils","_aggregation","_strings","_format","_colorUtils","_createForOfIteratorHelper","r","e","t","Symbol","iterator","Array","isArray","_unsupportedIterableToArray","length","_n","F","s","n","done","value","f","TypeError","o","a","u","call","next","_arrayLikeToArray","toString","slice","constructor","name","from","test","ownKeys","Object","keys","getOwnPropertySymbols","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","histogramFromThreshold","thresholds","values","valueAccessor","filterEmptyBins","undefined","getBins","d3Histogram","domain","bins","map","bin","count","indexes","x0","x1","b","histogramFromValues","numBins","isNumber","histogramFromDomain","ticks","getTimeBins","datasets","interval","timeBins","dataId","dataIdIdx","dataset","runGpuFilterForPlot","binByTime","mappedValue","getFilterMappedValue","intervalBins","getBinThresholds","idx","timeInterval","intervalToFunction","_domain","_slicedToArray2","t0","t1","floor","getTime","ceiling","ceil","durationDay","binThresholds","range","moment","utc","valueOf","lastStep","offset","skipIndexes","getSkipIndexes","_dataset$gpuFilter","gpuFilter","filterValueUpdateTriggers","filterRange","filterValueAccessor","filteredIndex","getFilterValue","dataContainer","allChannels","_","i","skipAll","includes","filterData","getFilterDataFunc","gpuFilters","valueIndex","findIndex","id","filterColumn","reduce","accu","item","skips","index","every","val","validBin","snapToMarks","marks","bisectLeft","normalizeValue","minValue","step","roundValToStep","isPercentField","field","metadata","numerator","denominator","updateAggregationByField","aggregation","AGGREGATION_TYPES","average","getAgregationType","getAggregationAccessor","fields","numeratorIdx","denominatorIdx","getNumerator","valueAt","getDenominator","getValueAggrFunc","exports","datasetField","find","aggregate","getAggregationOptiosnBasedOnField","TIME_AGGREGATION","_ref","sum","getDelta","y","lastBin","delta","pct","getPctChange","y0","Number","isFinite","getLineChart","_timeBins","yAxis","plotType","lineChart","seriesDataId","isEqual","getYValue","init","series","x","yDomain","extent","d","xDomain","split","splitSeries","aggrName","AGGREGATION_NAME","title","concat","fieldType","type","allTime","lines","temp","notNullorUndefined","markers","adjustValueToAnimationWindow","state","_filter$value","value0","value1","animationWindow","getInitialInterval","datasetBins","val0","val1","ANIMATION_WINDOW","indexOf","NaN","updatedFilter","getFilterPlotColorsByDataId","oldColorsByDataId","colorsByDataId","_iterator","_step","rgbToHex","color","err","updateTimeFilterPlotType","nextFilter","nextPlotType","_typeof2","getDefaultPlotType","PLOT_TYPES","histogram","getRangeFilterBins","acc","datasetIdx","_filter$bins","fieldName","getColumnField","updateRangeFilterPlotType","BINS","getChartTitle","yAxisName","displayName","capitalizeFirstLetter","defaultTimeFormat","getDefaultTimeFormat"],"sources":["../src/plot.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {bisectLeft, extent, histogram as d3Histogram, ticks} from 'd3-array';\nimport isEqual from 'lodash.isequal';\nimport {getFilterMappedValue, getInitialInterval, intervalToFunction} from './time';\nimport moment from 'moment';\nimport {\n  Bin,\n  TimeBins,\n  Millisecond,\n  TimeRangeFilter,\n  RangeFilter,\n  PlotType,\n  Filter,\n  LineChart,\n  Field,\n  ValueOf,\n  LineDatum\n} from '@kepler.gl/types';\nimport {notNullorUndefined} from '@kepler.gl/common-utils';\nimport {\n  ANIMATION_WINDOW,\n  BINS,\n  durationDay,\n  TIME_AGGREGATION,\n  AGGREGATION_TYPES,\n  PLOT_TYPES,\n  AggregationTypes\n} from '@kepler.gl/constants';\n\nimport {isNumber, roundValToStep} from './data-utils';\nimport {aggregate, AGGREGATION_NAME} from './aggregation';\nimport {capitalizeFirstLetter} from './strings';\nimport {getDefaultTimeFormat} from './format';\nimport {rgbToHex} from './color-utils';\nimport {DataContainerInterface} from '.';\nimport {KeplerTableModel} from './types';\n\n// TODO kepler-table module isn't accessible from utils. Add compatible interface to types\ntype Datasets = any;\n\n/**\n *\n * @param thresholds\n * @param values\n * @param indexes\n */\nexport function histogramFromThreshold(\n  thresholds: number[],\n  values: number[],\n  valueAccessor?: (d: unknown) => number,\n  filterEmptyBins = true\n): Bin[] {\n  const getBins = d3Histogram()\n    .domain([thresholds[0], thresholds[thresholds.length - 1]])\n    .thresholds(thresholds);\n\n  if (valueAccessor) {\n    getBins.value(valueAccessor);\n  }\n\n  // @ts-ignore\n  const bins = getBins(values).map(bin => ({\n    count: bin.length,\n    indexes: bin,\n    x0: bin.x0,\n    x1: bin.x1\n  }));\n\n  // d3-histogram ignores threshold values outside the domain\n  // The first bin.x0 is always equal to the minimum domain value, and the last bin.x1 is always equal to the maximum domain value.\n\n  // bins[0].x0 = thresholds[0];\n  // bins[bins.length - 1].x1 = thresholds[thresholds.length - 1];\n\n  // @ts-ignore\n  return filterEmptyBins ? bins.filter(b => b.count > 0) : bins;\n}\n\n/**\n *\n * @param values\n * @param numBins\n * @param valueAccessor\n */\nexport function histogramFromValues(\n  values: (Millisecond | null | number)[],\n  numBins: number,\n  valueAccessor?: (d: unknown) => number\n) {\n  const getBins = d3Histogram().thresholds(numBins);\n\n  if (valueAccessor) {\n    getBins.value(valueAccessor);\n  }\n\n  // @ts-ignore d3-array types doesn't match\n  return getBins(values)\n    .map(bin => ({\n      count: bin.length,\n      indexes: bin,\n      x0: bin.x0,\n      x1: bin.x1\n    }))\n    .filter(b => {\n      const {x0, x1} = b;\n      return isNumber(x0) && isNumber(x1);\n    });\n}\n\n/**\n *\n * @param domain\n * @param values\n * @param numBins\n * @param valueAccessor\n */\nexport function histogramFromDomain(\n  domain: [number, number],\n  values: (Millisecond | null | number)[],\n  numBins: number,\n  valueAccessor?: (d: unknown) => number\n): Bin[] {\n  const getBins = d3Histogram().thresholds(ticks(domain[0], domain[1], numBins)).domain(domain);\n  if (valueAccessor) {\n    getBins.value(valueAccessor);\n  }\n\n  // @ts-ignore d3-array types doesn't match\n  return getBins(values).map(bin => ({\n    count: bin.length,\n    indexes: bin,\n    x0: bin.x0,\n    x1: bin.x1\n  }));\n}\n\n/**\n * @param filter\n * @param datasets\n * @param interval\n */\nexport function getTimeBins(\n  filter: TimeRangeFilter,\n  datasets: Datasets,\n  interval: PlotType['interval']\n): TimeBins {\n  let bins = filter.timeBins || {};\n\n  filter.dataId.forEach((dataId, dataIdIdx) => {\n    // reuse bins if filterData did not change\n    if (bins[dataId] && bins[dataId][interval]) {\n      return;\n    }\n    const dataset = datasets[dataId];\n\n    // do not apply current filter\n    const indexes = runGpuFilterForPlot(dataset, filter);\n\n    bins = {\n      ...bins,\n      [dataId]: {\n        ...bins[dataId],\n        [interval]: binByTime(indexes, dataset, interval, filter)\n      }\n    };\n  });\n\n  return bins;\n}\n\nexport function binByTime(indexes, dataset, interval, filter) {\n  // gpuFilters need to be apply to filteredIndex\n  const mappedValue = getFilterMappedValue(dataset, filter);\n  if (!mappedValue) {\n    return null;\n  }\n  const intervalBins = getBinThresholds(interval, filter.domain);\n  const valueAccessor = idx => mappedValue[idx];\n  const bins = histogramFromThreshold(intervalBins, indexes, valueAccessor);\n\n  return bins;\n}\n\nexport function getBinThresholds(interval: string, domain: number[]): number[] {\n  const timeInterval = intervalToFunction(interval);\n  const [t0, t1] = domain;\n  const floor = timeInterval.floor(t0).getTime();\n  const ceiling = timeInterval.ceil(t1).getTime();\n\n  if (!timeInterval) {\n    // if time interval is not defined\n    // this should not happen\n    return [t0, t0 + durationDay];\n  }\n  const binThresholds = timeInterval.range(floor, ceiling + 1).map(t => moment.utc(t).valueOf());\n  const lastStep = binThresholds[binThresholds.length - 1];\n  if (lastStep === t1) {\n    // when last step equal to domain max, add one more step\n    binThresholds.push(moment.utc(timeInterval.offset(lastStep)).valueOf());\n  }\n\n  return binThresholds;\n}\n\n/**\n * Run GPU filter on current filter result to generate indexes for ploting chart\n * Skip ruuning for the same field\n * @param dataset\n * @param filter\n */\nexport function runGpuFilterForPlot<K extends KeplerTableModel<K, L>, L>(\n  dataset: K,\n  filter?: Filter\n): number[] {\n  const skipIndexes = getSkipIndexes(dataset, filter);\n\n  const {\n    gpuFilter: {filterValueUpdateTriggers, filterRange, filterValueAccessor},\n    filteredIndex\n  } = dataset;\n  const getFilterValue = filterValueAccessor(dataset.dataContainer)();\n\n  const allChannels = Object.keys(filterValueUpdateTriggers)\n    .map((_, i) => i)\n    .filter(i => Object.values(filterValueUpdateTriggers)[i]);\n  const skipAll = !allChannels.filter(i => !skipIndexes.includes(i)).length;\n  if (skipAll) {\n    return filteredIndex;\n  }\n\n  const filterData = getFilterDataFunc(\n    filterRange,\n    getFilterValue,\n    dataset.dataContainer,\n    skipIndexes\n  );\n\n  return filteredIndex.filter(filterData);\n}\n\nfunction getSkipIndexes(dataset, filter) {\n  // array of gpu filter names\n  if (!filter) {\n    return [];\n  }\n  const gpuFilters = Object.values(dataset.gpuFilter.filterValueUpdateTriggers) as ({\n    name: string;\n  } | null)[];\n  const valueIndex = filter.dataId.findIndex(id => id === dataset.id);\n  const filterColumn = filter.name[valueIndex];\n\n  return gpuFilters.reduce((accu, item, idx) => {\n    if (item && filterColumn === item.name) {\n      accu.push(idx);\n    }\n    return accu;\n  }, [] as number[]);\n}\n\nexport function getFilterDataFunc(\n  filterRange,\n  getFilterValue,\n  dataContainer: DataContainerInterface,\n  skips\n) {\n  return index =>\n    getFilterValue({index}).every(\n      (val, i) => skips.includes(i) || (val >= filterRange[i][0] && val <= filterRange[i][1])\n    );\n}\n\nexport function validBin(b) {\n  return b.x0 !== undefined && b.x1 !== undefined;\n}\n\n/**\n * Use in slider, given a number and an array of numbers, return the nears number from the array.\n * Takes a value, timesteps and return the actual step.\n * @param value\n * @param marks\n */\nexport function snapToMarks(value: number, marks: number[]): number {\n  // always use bin x0\n  if (!marks.length) {\n    // @ts-expect-error looking at the usage null return value isn't expected and requires extra handling in a lot of places\n    return null;\n  }\n  const i = bisectLeft(marks, value);\n  if (i === 0) {\n    return marks[i];\n  } else if (i === marks.length) {\n    return marks[i - 1];\n  }\n  const idx = marks[i] - value < value - marks[i - 1] ? i : i - 1;\n  return marks[idx];\n}\n\nexport function normalizeValue(val, minValue, step, marks) {\n  if (marks && marks.length) {\n    return snapToMarks(val, marks);\n  }\n\n  return roundValToStep(minValue, step, val);\n}\n\nexport function isPercentField(field) {\n  return field.metadata && field.metadata.numerator && field.metadata.denominator;\n}\n\nexport function updateAggregationByField(field: Field, aggregation: ValueOf<AggregationTypes>) {\n  // shouldn't apply sum to percent fiele type\n  // default aggregation is average\n  return field && isPercentField(field)\n    ? AGGREGATION_TYPES.average\n    : aggregation || AGGREGATION_TYPES.average;\n}\n\nconst getAgregationType = (field, aggregation) => {\n  if (isPercentField(field)) {\n    return 'mean_of_percent';\n  }\n  return aggregation;\n};\n\nconst getAggregationAccessor = (field, dataContainer: DataContainerInterface, fields) => {\n  if (isPercentField(field)) {\n    const numeratorIdx = fields.findIndex(f => f.name === field.metadata.numerator);\n    const denominatorIdx = fields.findIndex(f => f.name === field.metadata.denominator);\n\n    return {\n      getNumerator: i => dataContainer.valueAt(i, numeratorIdx),\n      getDenominator: i => dataContainer.valueAt(i, denominatorIdx)\n    };\n  }\n\n  return i => field.valueAccessor({index: i});\n};\n\nexport const getValueAggrFunc = (\n  field: Field | string | null,\n  aggregation: string,\n  dataset: KeplerTableModel<any, any>\n): ((bin: Bin) => number) => {\n  const {dataContainer, fields} = dataset;\n\n  // The passed-in field might not have all the fields set (e.g. valueAccessor)\n  const datasetField = fields.find(\n    f => field && (f.name === field || f.name === (field as Field).name)\n  );\n\n  return datasetField && aggregation\n    ? bin =>\n        aggregate(\n          bin.indexes,\n          getAgregationType(datasetField, aggregation),\n          // @ts-expect-error can return {getNumerator, getDenominator}\n          getAggregationAccessor(datasetField, dataContainer, fields)\n        )\n    : bin => bin.count;\n};\n\nexport const getAggregationOptiosnBasedOnField = field => {\n  if (isPercentField(field)) {\n    // don't show sum\n    return TIME_AGGREGATION.filter(({id}) => id !== AGGREGATION_TYPES.sum);\n  }\n  return TIME_AGGREGATION;\n};\n\nfunction getDelta(\n  bins: LineDatum[],\n  y: number,\n  interval: PlotType['interval']\n): Partial<LineDatum> & {delta: 'last'; pct: number | null} {\n  // if (WOW[interval]) return getWow(bins, y, interval);\n  const lastBin = bins[bins.length - 1];\n\n  return {\n    delta: 'last',\n    pct: lastBin ? getPctChange(y, lastBin.y) : null\n  };\n}\n\nexport function getPctChange(y: unknown, y0: unknown): number | null {\n  if (Number.isFinite(y) && Number.isFinite(y0) && y0 !== 0) {\n    return ((y as number) - (y0 as number)) / (y0 as number);\n  }\n  return null;\n}\n\n/**\n *\n * @param datasets\n * @param filter\n */\nexport function getLineChart(datasets: Datasets, filter: Filter): LineChart {\n  const {dataId, yAxis, plotType, lineChart} = filter;\n  const {aggregation, interval} = plotType;\n  const seriesDataId = dataId[0];\n  const bins = (filter as TimeRangeFilter).timeBins?.[seriesDataId]?.[interval];\n\n  if (\n    lineChart &&\n    lineChart.aggregation === aggregation &&\n    lineChart.interval === interval &&\n    lineChart.yAxis === yAxis?.name &&\n    // we need to make sure we validate bins because of cross filter data changes\n    isEqual(bins, lineChart?.bins)\n  ) {\n    // don't update lineChart if plotType hasn't change\n    return lineChart;\n  }\n\n  const dataset = datasets[seriesDataId];\n  const getYValue = getValueAggrFunc(yAxis, aggregation, dataset);\n\n  const init: LineDatum[] = [];\n  const series = (bins || []).reduce((accu, bin, i) => {\n    const y = getYValue(bin);\n    const delta = getDelta(accu, y, interval);\n    accu.push({\n      x: bin.x0,\n      y,\n      ...delta\n    });\n    return accu;\n  }, init);\n\n  const yDomain = extent<{y: any}>(series, d => d.y);\n  const xDomain = bins ? [bins[0].x0, bins[bins.length - 1].x1] : [];\n\n  // treat missing data as another series\n  const split = splitSeries(series);\n  const aggrName = AGGREGATION_NAME[aggregation];\n\n  return {\n    // @ts-ignore\n    yDomain,\n    // @ts-ignore\n    xDomain,\n    interval,\n    aggregation,\n    // @ts-ignore\n    series: split,\n    title: `${aggrName}${' of '}${yAxis ? yAxis.name : 'Count'}`,\n    fieldType: yAxis ? yAxis.type : 'integer',\n    yAxis: yAxis ? yAxis.name : null,\n    allTime: {\n      title: `All Time Average`,\n      value: aggregate(series, AGGREGATION_TYPES.average, d => d.y)\n    },\n    // @ts-expect-error bins is Bins[], not a Bins map. Refactor to use correct types.\n    bins\n  };\n}\n\n// split into multiple series when see missing data\nexport function splitSeries(series) {\n  const lines: any[] = [];\n  let temp: any[] = [];\n  for (let i = 0; i < series.length; i++) {\n    const d = series[i];\n    if (!notNullorUndefined(d.y) && temp.length) {\n      // ends temp\n      lines.push(temp);\n      temp = [];\n    } else if (notNullorUndefined(d.y)) {\n      temp.push(d);\n    }\n\n    if (i === series.length - 1 && temp.length) {\n      lines.push(temp);\n    }\n  }\n\n  const markers = lines.length > 1 ? series.filter(d => notNullorUndefined(d.y)) : [];\n\n  return {lines, markers};\n}\n\ntype MinVisStateForAnimationWindow = {\n  datasets: Datasets;\n};\n\nexport function adjustValueToAnimationWindow<S extends MinVisStateForAnimationWindow>(\n  state: S,\n  filter: TimeRangeFilter\n) {\n  const {\n    plotType,\n    value: [value0, value1],\n    animationWindow\n  } = filter;\n\n  const interval = plotType.interval || getInitialInterval(filter, state.datasets);\n  const bins = getTimeBins(filter, state.datasets, interval);\n  const datasetBins = bins && Object.keys(bins).length && Object.values(bins)[0][interval];\n  const thresholds = (datasetBins || []).map(b => b.x0);\n\n  let val0 = value0;\n  let val1 = value1;\n  let idx;\n  if (animationWindow === ANIMATION_WINDOW.interval) {\n    val0 = snapToMarks(value1, thresholds);\n    idx = thresholds.indexOf(val0);\n    val1 = idx > -1 ? datasetBins[idx].x1 : NaN;\n  } else {\n    // fit current value to window\n    val0 = snapToMarks(value0, thresholds);\n    val1 = snapToMarks(value1, thresholds);\n\n    if (val0 === val1) {\n      idx = thresholds.indexOf(val0);\n      if (idx === thresholds.length - 1) {\n        val0 = thresholds[idx - 1];\n      } else {\n        val1 = thresholds[idx + 1];\n      }\n    }\n  }\n\n  const updatedFilter = {\n    ...filter,\n    plotType: {\n      ...filter.plotType,\n      interval\n    },\n    timeBins: bins,\n    value: [val0, val1]\n  };\n\n  return updatedFilter;\n}\n\n/**\n * Create or update colors for a filter plot\n * @param filter\n * @param datasets\n * @param oldColorsByDataId\n */\nfunction getFilterPlotColorsByDataId(filter, datasets, oldColorsByDataId) {\n  let colorsByDataId = oldColorsByDataId || {};\n  for (const dataId of filter.dataId) {\n    if (!colorsByDataId[dataId] && datasets[dataId]) {\n      colorsByDataId = {\n        ...colorsByDataId,\n        [dataId]: rgbToHex(datasets[dataId].color)\n      };\n    }\n  }\n  return colorsByDataId;\n}\n\n/**\n *\n * @param filter\n * @param plotType\n * @param datasets\n * @param dataId\n */\nexport function updateTimeFilterPlotType(\n  filter: TimeRangeFilter,\n  plotType: TimeRangeFilter['plotType'],\n  datasets: Datasets,\n  dataId?: string\n): TimeRangeFilter {\n  let nextFilter = filter;\n  let nextPlotType = plotType;\n  if (typeof nextPlotType !== 'object' || !nextPlotType.aggregation || !nextPlotType.interval) {\n    nextPlotType = getDefaultPlotType(filter, datasets);\n  }\n\n  if (filter.dataId.length > 1) {\n    nextPlotType = {\n      ...nextPlotType,\n      colorsByDataId: getFilterPlotColorsByDataId(filter, datasets, nextPlotType.colorsByDataId)\n    };\n  }\n  nextFilter = {\n    ...nextFilter,\n    plotType: nextPlotType\n  };\n\n  const bins = getTimeBins(nextFilter, datasets, nextPlotType.interval);\n\n  nextFilter = {\n    ...nextFilter,\n    timeBins: bins\n  };\n\n  if (plotType.type === PLOT_TYPES.histogram) {\n    // Histogram is calculated and memoized in the chart itself\n  } else if (plotType.type === PLOT_TYPES.lineChart) {\n    // we should be able to move this into its own component so react will do the shallow comparison for us.\n    nextFilter = {\n      ...nextFilter,\n      lineChart: getLineChart(datasets, nextFilter)\n    };\n  }\n\n  return nextFilter;\n}\n\nexport function getRangeFilterBins(filter, datasets, numBins) {\n  const {domain} = filter;\n  if (!filter.dataId) return null;\n\n  return filter.dataId.reduce((acc, dataId, datasetIdx) => {\n    if (filter.bins?.[dataId]) {\n      // don't recalculate bins\n      acc[dataId] = filter.bins[dataId];\n      return acc;\n    }\n    const fieldName = filter.name[datasetIdx];\n    if (dataId && fieldName) {\n      const dataset = datasets[dataId];\n      const field = dataset?.getColumnField(fieldName);\n      if (dataset && field) {\n        const indexes = runGpuFilterForPlot(dataset, filter);\n        const valueAccessor = index => field.valueAccessor({index});\n        acc[dataId] = histogramFromDomain(domain, indexes, numBins, valueAccessor);\n      }\n    }\n    return acc;\n  }, {});\n}\n\nexport function updateRangeFilterPlotType(\n  filter: RangeFilter,\n  plotType: RangeFilter['plotType'],\n  datasets: Datasets,\n  dataId?: string\n): RangeFilter {\n  const nextFilter = {\n    ...filter,\n    plotType\n  };\n\n  // if (dataId) {\n  //   // clear bins\n  //   nextFilter = {\n  //     ...nextFilter,\n  //     bins: {\n  //       ...nextFilter.bins,\n  //       [dataId]: null\n  //     }\n  //   };\n  // }\n\n  return {\n    ...filter,\n    plotType,\n    bins: getRangeFilterBins(nextFilter, datasets, BINS)\n  };\n}\n\nexport function getChartTitle(\n  yAxis: {displayName?: string},\n  plotType: {aggregation: string}\n): string {\n  const yAxisName = yAxis?.displayName;\n  const {aggregation} = plotType;\n\n  if (yAxisName) {\n    return capitalizeFirstLetter(`${aggregation} ${yAxisName} over Time`);\n  }\n\n  return `Count of Rows over Time`;\n}\n\nexport function getDefaultPlotType(filter, datasets) {\n  const interval = getInitialInterval(filter, datasets);\n  const defaultTimeFormat = getDefaultTimeFormat(interval);\n  return {\n    interval,\n    defaultTimeFormat,\n    type: PLOT_TYPES.histogram,\n    aggregation: AGGREGATION_TYPES.sum\n  };\n}\n"],"mappings":"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","ignoreList":[]}