dygraphs/src-es5/datahandler/datahandler.js

dygraphs is a fast, flexible open source JavaScript charting library.

/**
 * @license
 * Copyright 2013 David Eberlein (david.eberlein@ch.sauter-bc.com)
 * MIT-licenced: https://opensource.org/licenses/MIT
 */

/**
 * @fileoverview This file contains the managment of data handlers
 * @author David Eberlein (david.eberlein@ch.sauter-bc.com)
 *
 * The idea is to define a common, generic data format that works for all data
 * structures supported by dygraphs. To make this possible, the DataHandler
 * interface is introduced. This makes it possible, that dygraph itself can work
 * with the same logic for every data type independent of the actual format and
 * the DataHandler takes care of the data format specific jobs.
 * DataHandlers are implemented for all data types supported by Dygraphs and
 * return Dygraphs compliant formats.
 * By default the correct DataHandler is chosen based on the options set.
 * Optionally the user may use his own DataHandler (similar to the plugin
 * system).
 *
 *
 * The unified data format returend by each handler is defined as so:
 * series[n][point] = [x,y,(extras)]
 *
 * This format contains the common basis that is needed to draw a simple line
 * series extended by optional extras for more complex graphing types. It
 * contains a primitive x value as first array entry, a primitive y value as
 * second array entry and an optional extras object for additional data needed.
 *
 * x must always be a number.
 * y must always be a number, NaN of type number or null.
 * extras is optional and must be interpreted by the DataHandler. It may be of
 * any type.
 *
 * In practice this might look something like this:
 * default: [x, yVal]
 * errorBar / customBar: [x, yVal, [yTopVariance, yBottomVariance] ]
 *
 */
/*global Dygraph:false */
/*global DygraphLayout:false */

"use strict";

/**
 *
 * The data handler is responsible for all data specific operations. All of the
 * series data it receives and returns is always in the unified data format.
 * Initially the unified data is created by the extractSeries method
 * @constructor
 */
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;
var DygraphDataHandler = function DygraphDataHandler() {};
var handler = DygraphDataHandler;

/**
 * X-value array index constant for unified data samples.
 * @const
 * @type {number}
 */
handler.X = 0;

/**
 * Y-value array index constant for unified data samples.
 * @const
 * @type {number}
 */
handler.Y = 1;

/**
 * Extras-value array index constant for unified data samples.
 * @const
 * @type {number}
 */
handler.EXTRAS = 2;

/**
 * Extracts one series from the raw data (a 2D array) into an array of the
 * unified data format.
 * This is where undesirable points (i.e. negative values on log scales and
 * missing values through which we wish to connect lines) are dropped.
 * TODO(danvk): the "missing values" bit above doesn't seem right.
 *
 * @param {!Array.<Array>} rawData The raw data passed into dygraphs where
 *     rawData[i] = [x,ySeries1,...,ySeriesN].
 * @param {!number} seriesIndex Index of the series to extract. All other
 *     series should be ignored.
 * @param {!DygraphOptions} options Dygraph options.
 * @return {Array.<[!number,?number,?]>} The series in the unified data format
 *     where series[i] = [x,y,{extras}].
 */
handler.prototype.extractSeries = function (rawData, seriesIndex, options) {};

/**
 * Converts a series to a Point array.  The resulting point array must be
 * returned in increasing order of idx property.
 *
 * @param {!Array.<[!number,?number,?]>} series The series in the unified
 *          data format where series[i] = [x,y,{extras}].
 * @param {!string} setName Name of the series.
 * @param {!number} boundaryIdStart Index offset of the first point, equal to the
 *          number of skipped points left of the date window minimum (if any).
 * @return {!Array.<Dygraph.PointType>} List of points for this series.
 */
handler.prototype.seriesToPoints = function (series, setName, boundaryIdStart) {
  // TODO(bhs): these loops are a hot-spot for high-point-count charts. In
  // fact,
  // on chrome+linux, they are 6 times more expensive than iterating through
  // the
  // points and drawing the lines. The brunt of the cost comes from allocating
  // the |point| structures.
  var points = [];
  for (var i = 0; i < series.length; ++i) {
    var item = series[i];
    var yraw = item[1];
    var yval = yraw === null ? null : handler.parseFloat(yraw);
    var point = {
      x: NaN,
      y: NaN,
      xval: handler.parseFloat(item[0]),
      yval: yval,
      name: setName,
      // TODO(danvk): is this really necessary?
      idx: i + boundaryIdStart,
      canvasx: NaN,
      // add these so we do not alter the structure later, which slows Chrome
      canvasy: NaN
    };
    points.push(point);
  }
  this.onPointsCreated_(series, points);
  return points;
};

/**
 * Callback called for each series after the series points have been generated
 * which will later be used by the plotters to draw the graph.
 * Here data may be added to the seriesPoints which is needed by the plotters.
 * The indexes of series and points are in sync meaning the original data
 * sample for series[i] is points[i].
 *
 * @param {!Array.<[!number,?number,?]>} series The series in the unified
 *     data format where series[i] = [x,y,{extras}].
 * @param {!Array.<Dygraph.PointType>} points The corresponding points passed
 *     to the plotter.
 * @protected
 */
handler.prototype.onPointsCreated_ = function (series, points) {};

/**
 * Calculates the rolling average of a data set.
 *
 * @param {!Array.<[!number,?number,?]>} series The series in the unified
 *          data format where series[i] = [x,y,{extras}].
 * @param {!number} rollPeriod The number of points over which to average the data
 * @param {!DygraphOptions} options The dygraph options.
 * @param {!number} seriesIndex Index of the series this was extracted from.
 * @return {!Array.<[!number,?number,?]>} the rolled series.
 */
handler.prototype.rollingAverage = function (series, rollPeriod, options, seriesIndex) {};

/**
 * Computes the range of the data series (including confidence intervals).
 *
 * @param {!Array.<[!number,?number,?]>} series The series in the unified
 *     data format where series[i] = [x, y, {extras}].
 * @param {!Array.<number>} dateWindow The x-value range to display with
 *     the format: [min, max].
 * @param {boolean} stepPlot Whether the stepPlot option is set.
 * @return {Array.<number>} The low and high extremes of the series in the
 *     given window with the format: [low, high].
 */
handler.prototype.getExtremeYValues = function (series, dateWindow, stepPlot) {};

/**
 * Callback called for each series after the layouting data has been
 * calculated before the series is drawn. Here normalized positioning data
 * should be calculated for the extras of each point.
 *
 * @param {!Array.<Dygraph.PointType>} points The points passed to
 *          the plotter.
 * @param {!Object} axis The axis on which the series will be plotted.
 * @param {!boolean} logscale Whether or not to use a logscale.
 */
handler.prototype.onLineEvaluated = function (points, axis, logscale) {};

/**
 * Optimized replacement for parseFloat, which was way too slow when almost
 * all values were type number, with few edge cases, none of which were strings.
 * @param {?number} val
 * @return {number}
 * @protected
 */
handler.parseFloat = function (val) {
  // parseFloat(null) is NaN
  if (val === null) {
    return NaN;
  }

  // Assume it's a number or NaN. If it's something else, I'll be shocked.
  return val;
};
var _default = DygraphDataHandler;
exports["default"] = _default;
module.exports = exports.default;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["DygraphDataHandler","handler","X","Y","EXTRAS","prototype","extractSeries","rawData","seriesIndex","options","seriesToPoints","series","setName","boundaryIdStart","points","i","length","item","yraw","yval","parseFloat","point","x","NaN","y","xval","name","idx","canvasx","canvasy","push","onPointsCreated_","rollingAverage","rollPeriod","getExtremeYValues","dateWindow","stepPlot","onLineEvaluated","axis","logscale","val"],"sources":["../../src/datahandler/datahandler.js"],"sourcesContent":["/**\n * @license\n * Copyright 2013 David Eberlein (david.eberlein@ch.sauter-bc.com)\n * MIT-licenced: https://opensource.org/licenses/MIT\n */\n\n/**\n * @fileoverview This file contains the managment of data handlers\n * @author David Eberlein (david.eberlein@ch.sauter-bc.com)\n *\n * The idea is to define a common, generic data format that works for all data\n * structures supported by dygraphs. To make this possible, the DataHandler\n * interface is introduced. This makes it possible, that dygraph itself can work\n * with the same logic for every data type independent of the actual format and\n * the DataHandler takes care of the data format specific jobs.\n * DataHandlers are implemented for all data types supported by Dygraphs and\n * return Dygraphs compliant formats.\n * By default the correct DataHandler is chosen based on the options set.\n * Optionally the user may use his own DataHandler (similar to the plugin\n * system).\n *\n *\n * The unified data format returend by each handler is defined as so:\n * series[n][point] = [x,y,(extras)]\n *\n * This format contains the common basis that is needed to draw a simple line\n * series extended by optional extras for more complex graphing types. It\n * contains a primitive x value as first array entry, a primitive y value as\n * second array entry and an optional extras object for additional data needed.\n *\n * x must always be a number.\n * y must always be a number, NaN of type number or null.\n * extras is optional and must be interpreted by the DataHandler. It may be of\n * any type.\n *\n * In practice this might look something like this:\n * default: [x, yVal]\n * errorBar / customBar: [x, yVal, [yTopVariance, yBottomVariance] ]\n *\n */\n/*global Dygraph:false */\n/*global DygraphLayout:false */\n\n\"use strict\";\n\n/**\n *\n * The data handler is responsible for all data specific operations. All of the\n * series data it receives and returns is always in the unified data format.\n * Initially the unified data is created by the extractSeries method\n * @constructor\n */\nvar DygraphDataHandler = function () {\n};\n\nvar handler = DygraphDataHandler;\n\n/**\n * X-value array index constant for unified data samples.\n * @const\n * @type {number}\n */\nhandler.X = 0;\n\n/**\n * Y-value array index constant for unified data samples.\n * @const\n * @type {number}\n */\nhandler.Y = 1;\n\n/**\n * Extras-value array index constant for unified data samples.\n * @const\n * @type {number}\n */\nhandler.EXTRAS = 2;\n\n/**\n * Extracts one series from the raw data (a 2D array) into an array of the\n * unified data format.\n * This is where undesirable points (i.e. negative values on log scales and\n * missing values through which we wish to connect lines) are dropped.\n * TODO(danvk): the \"missing values\" bit above doesn't seem right.\n *\n * @param {!Array.<Array>} rawData The raw data passed into dygraphs where\n *     rawData[i] = [x,ySeries1,...,ySeriesN].\n * @param {!number} seriesIndex Index of the series to extract. All other\n *     series should be ignored.\n * @param {!DygraphOptions} options Dygraph options.\n * @return {Array.<[!number,?number,?]>} The series in the unified data format\n *     where series[i] = [x,y,{extras}].\n */\nhandler.prototype.extractSeries = function(rawData, seriesIndex, options) {\n};\n\n/**\n * Converts a series to a Point array.  The resulting point array must be\n * returned in increasing order of idx property.\n *\n * @param {!Array.<[!number,?number,?]>} series The series in the unified\n *          data format where series[i] = [x,y,{extras}].\n * @param {!string} setName Name of the series.\n * @param {!number} boundaryIdStart Index offset of the first point, equal to the\n *          number of skipped points left of the date window minimum (if any).\n * @return {!Array.<Dygraph.PointType>} List of points for this series.\n */\nhandler.prototype.seriesToPoints = function(series, setName, boundaryIdStart) {\n  // TODO(bhs): these loops are a hot-spot for high-point-count charts. In\n  // fact,\n  // on chrome+linux, they are 6 times more expensive than iterating through\n  // the\n  // points and drawing the lines. The brunt of the cost comes from allocating\n  // the |point| structures.\n  var points = [];\n  for ( var i = 0; i < series.length; ++i) {\n    var item = series[i];\n    var yraw = item[1];\n    var yval = yraw === null ? null : handler.parseFloat(yraw);\n    var point = {\n      x : NaN,\n      y : NaN,\n      xval : handler.parseFloat(item[0]),\n      yval : yval,\n      name : setName, // TODO(danvk): is this really necessary?\n      idx : i + boundaryIdStart,\n      canvasx: NaN, // add these so we do not alter the structure later, which slows Chrome\n      canvasy: NaN,\n    };\n    points.push(point);\n  }\n  this.onPointsCreated_(series, points);\n  return points;\n};\n\n/**\n * Callback called for each series after the series points have been generated\n * which will later be used by the plotters to draw the graph.\n * Here data may be added to the seriesPoints which is needed by the plotters.\n * The indexes of series and points are in sync meaning the original data\n * sample for series[i] is points[i].\n *\n * @param {!Array.<[!number,?number,?]>} series The series in the unified\n *     data format where series[i] = [x,y,{extras}].\n * @param {!Array.<Dygraph.PointType>} points The corresponding points passed\n *     to the plotter.\n * @protected\n */\nhandler.prototype.onPointsCreated_ = function(series, points) {\n};\n\n/**\n * Calculates the rolling average of a data set.\n *\n * @param {!Array.<[!number,?number,?]>} series The series in the unified\n *          data format where series[i] = [x,y,{extras}].\n * @param {!number} rollPeriod The number of points over which to average the data\n * @param {!DygraphOptions} options The dygraph options.\n * @param {!number} seriesIndex Index of the series this was extracted from.\n * @return {!Array.<[!number,?number,?]>} the rolled series.\n */\nhandler.prototype.rollingAverage = function(series, rollPeriod, options, seriesIndex) {\n};\n\n/**\n * Computes the range of the data series (including confidence intervals).\n *\n * @param {!Array.<[!number,?number,?]>} series The series in the unified\n *     data format where series[i] = [x, y, {extras}].\n * @param {!Array.<number>} dateWindow The x-value range to display with\n *     the format: [min, max].\n * @param {boolean} stepPlot Whether the stepPlot option is set.\n * @return {Array.<number>} The low and high extremes of the series in the\n *     given window with the format: [low, high].\n */\nhandler.prototype.getExtremeYValues = function(series, dateWindow, stepPlot) {\n};\n\n/**\n * Callback called for each series after the layouting data has been\n * calculated before the series is drawn. Here normalized positioning data\n * should be calculated for the extras of each point.\n *\n * @param {!Array.<Dygraph.PointType>} points The points passed to\n *          the plotter.\n * @param {!Object} axis The axis on which the series will be plotted.\n * @param {!boolean} logscale Whether or not to use a logscale.\n */\nhandler.prototype.onLineEvaluated = function(points, axis, logscale) {\n};\n\n/**\n * Optimized replacement for parseFloat, which was way too slow when almost\n * all values were type number, with few edge cases, none of which were strings.\n * @param {?number} val\n * @return {number}\n * @protected\n */\nhandler.parseFloat = function(val) {\n  // parseFloat(null) is NaN\n  if (val === null) {\n    return NaN;\n  }\n\n  // Assume it's a number or NaN. If it's something else, I'll be shocked.\n  return val;\n};\n\nexport default DygraphDataHandler;\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,YAAY;;AAEZ;AACA;AACA;AACA;AACA;AACA;AACA;AANA;EAAA;AAAA;AAAA;AAOA,IAAIA,kBAAkB,GAAG,SAArBA,kBAAkB,GAAe,CACrC,CAAC;AAED,IAAIC,OAAO,GAAGD,kBAAkB;;AAEhC;AACA;AACA;AACA;AACA;AACAC,OAAO,CAACC,CAAC,GAAG,CAAC;;AAEb;AACA;AACA;AACA;AACA;AACAD,OAAO,CAACE,CAAC,GAAG,CAAC;;AAEb;AACA;AACA;AACA;AACA;AACAF,OAAO,CAACG,MAAM,GAAG,CAAC;;AAElB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAH,OAAO,CAACI,SAAS,CAACC,aAAa,GAAG,UAASC,OAAO,EAAEC,WAAW,EAAEC,OAAO,EAAE,CAC1E,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAR,OAAO,CAACI,SAAS,CAACK,cAAc,GAAG,UAASC,MAAM,EAAEC,OAAO,EAAEC,eAAe,EAAE;EAC5E;EACA;EACA;EACA;EACA;EACA;EACA,IAAIC,MAAM,GAAG,EAAE;EACf,KAAM,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGJ,MAAM,CAACK,MAAM,EAAE,EAAED,CAAC,EAAE;IACvC,IAAIE,IAAI,GAAGN,MAAM,CAACI,CAAC,CAAC;IACpB,IAAIG,IAAI,GAAGD,IAAI,CAAC,CAAC,CAAC;IAClB,IAAIE,IAAI,GAAGD,IAAI,KAAK,IAAI,GAAG,IAAI,GAAGjB,OAAO,CAACmB,UAAU,CAACF,IAAI,CAAC;IAC1D,IAAIG,KAAK,GAAG;MACVC,CAAC,EAAGC,GAAG;MACPC,CAAC,EAAGD,GAAG;MACPE,IAAI,EAAGxB,OAAO,CAACmB,UAAU,CAACH,IAAI,CAAC,CAAC,CAAC,CAAC;MAClCE,IAAI,EAAGA,IAAI;MACXO,IAAI,EAAGd,OAAO;MAAE;MAChBe,GAAG,EAAGZ,CAAC,GAAGF,eAAe;MACzBe,OAAO,EAAEL,GAAG;MAAE;MACdM,OAAO,EAAEN;IACX,CAAC;IACDT,MAAM,CAACgB,IAAI,CAACT,KAAK,CAAC;EACpB;EACA,IAAI,CAACU,gBAAgB,CAACpB,MAAM,EAAEG,MAAM,CAAC;EACrC,OAAOA,MAAM;AACf,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAb,OAAO,CAACI,SAAS,CAAC0B,gBAAgB,GAAG,UAASpB,MAAM,EAAEG,MAAM,EAAE,CAC9D,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAb,OAAO,CAACI,SAAS,CAAC2B,cAAc,GAAG,UAASrB,MAAM,EAAEsB,UAAU,EAAExB,OAAO,EAAED,WAAW,EAAE,CACtF,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAP,OAAO,CAACI,SAAS,CAAC6B,iBAAiB,GAAG,UAASvB,MAAM,EAAEwB,UAAU,EAAEC,QAAQ,EAAE,CAC7E,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAnC,OAAO,CAACI,SAAS,CAACgC,eAAe,GAAG,UAASvB,MAAM,EAAEwB,IAAI,EAAEC,QAAQ,EAAE,CACrE,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACAtC,OAAO,CAACmB,UAAU,GAAG,UAASoB,GAAG,EAAE;EACjC;EACA,IAAIA,GAAG,KAAK,IAAI,EAAE;IAChB,OAAOjB,GAAG;EACZ;;EAEA;EACA,OAAOiB,GAAG;AACZ,CAAC;AAAC,eAEaxC,kBAAkB;AAAA;AAAA"}