Merge pull request #1 from flant/release_001

Prepare release 0.0.1

README.md

@@ -1,19 +1,89 @@
-### Development
+# Statusmap panel for Grafana
+
+![Statusmap sample panel](https://raw.githubusercontent.com/flant/grafana-statusmap/master/src/img/flant-statusmap-panel.png)
+
+## Features
+
+* Group values into rows and buckets by query's legend
+* User defined color mapping
+* Multiple values in bucket display in tooltip
+* Interval shaping to better visual representation
+* Represent null values as empty bucket or as zero value
+
+### Supported environment
+
+* Prometheus datasource
+* Tested with Grafana 5.1.3
+
+
+## Motivation
+
+This plugin emerges from our needs to visually represent history of changes for a set of objects
+with discrete statuses.
+_Objects_ can be hosts, Kubernetes pods or coffee makers and _discrete statuses_ are a set
+of predefined values: something like `ok` = 0, `off` = 1, `fail` = 2.
+
+## Configuration
+
+Recommended setup is to create query for each possible status value with similar legend:
+
+![Query setup](https://raw.githubusercontent.com/flant/grafana-statusmap/master/src/img/queries-example.png)
+
+Next define color mapping for status values in __Discrete__ color mode.
+
+![Color mapping](https://raw.githubusercontent.com/flant/grafana-statusmap/master/src/img/color-mapping.png)
+
+
+__Spectrum__ and __Opacity__ color modes works as in a [Heatmap](https://grafana.com/plugins/heatmap) plugin.
+
+
+### More options
+
+![Bucket options](https://raw.githubusercontent.com/flant/grafana-statusmap/master/src/img/options-bucket.png)
+
+__Multiple values__ check determine multiple values display mode. If check is unset then multiple values
+for one bucket treated as error. If check is on then color for bucket determined
+by value with least index in color mapping.
+
+![Color mapping](https://raw.githubusercontent.com/flant/grafana-statusmap/master/src/img/multiple-values-error.png)
+
+__Null values__ can be treated as empty buckets or displayed as color of 0 value.
+
+![Color mapping](https://raw.githubusercontent.com/flant/grafana-statusmap/master/src/img/null-as-empty.png)
+
+__Min width__ and __spacing__ are determine minimal bucket width and vertical and horizontal spacing between buckets.
+__Rounding__ is for round edges.
+
+![Min width, spacing, rounding](https://raw.githubusercontent.com/flant/grafana-statusmap/master/src/img/min-width-spacing-rounding.png)
+
+
+## Development
+
+The easy way to test and develop plugin is to run Grafana instance in docker with following command in the directory containing the plugin.
+This will expose the local plugin on your machine to the Grafana container.
 
 ```
-docker run --rm -it -v $PWD:/var/lib/grafana/plugins/status-heatmap-panel \
+docker run --rm -it -v $PWD:/var/lib/grafana/plugins/flant-statusmap-panel \
            -p 3000:3000 --name grafana.docker \
            --env=GF_USERS_DEFAULT_THEME=light \
            grafana/grafana:5.1.3
 ```
 
+Now run `grunt` to compile dist directory and start changes watcher:
+
 ```
 grunt watch
 ```
 
-Prometheus
+## Acknowledgements
+
+Idea of a plugin comes from Dmitry Stolyarov @distol, initial version written by Sergey Gnuskov @gsmetal and final changes made by Ivan Mikheykin @diafour.
+
+This plugin is based on a "Heatmap" panel by Grafana and inspired by ideas from Carpet plot, Discrete panel, Status Panel, Status Dot, Status By Group.
+
+#### Changelog
+
+##### v0.0.1
+
+- First public release
 
-```
-ssh kube-cluster -L 3001:localhost:9001
-kubectl port-forward prometheus-0 9001:9090 -n prom-namespace
-```

dist/README.md

@@ -0,0 +1,89 @@
+# Statusmap panel for Grafana
+
+![Statusmap sample panel](https://raw.githubusercontent.com/flant/grafana-statusmap/master/src/img/flant-statusmap-panel.png)
+
+## Features
+
+* Group values into rows and buckets by query's legend
+* User defined color mapping
+* Multiple values in bucket display in tooltip
+* Interval shaping to better visual representation
+* Represent null values as empty bucket or as zero value
+
+### Supported environment
+
+* Prometheus datasource
+* Tested with Grafana 5.1.3
+
+
+## Motivation
+
+This plugin emerges from our needs to visually represent history of changes for a set of objects
+with discrete statuses.
+_Objects_ can be hosts, Kubernetes pods or coffee makers and _discrete statuses_ are a set
+of predefined values: something like `ok` = 0, `off` = 1, `fail` = 2.
+
+## Configuration
+
+Recommended setup is to create query for each possible status value with similar legend:
+
+![Query setup](https://raw.githubusercontent.com/flant/grafana-statusmap/master/src/img/queries-example.png)
+
+Next define color mapping for status values in __Discrete__ color mode.
+
+![Color mapping](https://raw.githubusercontent.com/flant/grafana-statusmap/master/src/img/color-mapping.png)
+
+
+__Spectrum__ and __Opacity__ color modes works as in a [Heatmap](https://grafana.com/plugins/heatmap) plugin.
+
+
+### More options
+
+![Bucket options](https://raw.githubusercontent.com/flant/grafana-statusmap/master/src/img/options-bucket.png)
+
+__Multiple values__ check determine multiple values display mode. If check is unset then multiple values
+for one bucket treated as error. If check is on then color for bucket determined
+by value with least index in color mapping.
+
+![Color mapping](https://raw.githubusercontent.com/flant/grafana-statusmap/master/src/img/multiple-values-error.png)
+
+__Null values__ can be treated as empty buckets or displayed as color of 0 value.
+
+![Color mapping](https://raw.githubusercontent.com/flant/grafana-statusmap/master/src/img/null-as-empty.png)
+
+__Min width__ and __spacing__ are determine minimal bucket width and vertical and horizontal spacing between buckets.
+__Rounding__ is for round edges.
+
+![Min width, spacing, rounding](https://raw.githubusercontent.com/flant/grafana-statusmap/master/src/img/min-width-spacing-rounding.png)
+
+
+## Development
+
+The easy way to test and develop plugin is to run Grafana instance in docker with following command in the directory containing the plugin.
+This will expose the local plugin on your machine to the Grafana container.
+
+```
+docker run --rm -it -v $PWD:/var/lib/grafana/plugins/flant-statusmap-panel \
+           -p 3000:3000 --name grafana.docker \
+           --env=GF_USERS_DEFAULT_THEME=light \
+           grafana/grafana:5.1.3
+```
+
+Now run `grunt` to compile dist directory and start changes watcher:
+
+```
+grunt watch
+```
+
+## Acknowledgements
+
+Idea of a plugin comes from Dmitry Stolyarov @distol, initial version written by Sergey Gnuskov @gsmetal and final changes made by Ivan Mikheykin @diafour.
+
+This plugin is based on a "Heatmap" panel by Grafana and inspired by ideas from Carpet plot, Discrete panel, Status Panel, Status Dot, Status By Group.
+
+#### Changelog
+
+##### v0.0.1
+
+- First public release
+

dist/color_legend.js

@@ -0,0 +1,411 @@
+'use strict';
+
+System.register(['angular', 'lodash', 'jquery', 'd3', './libs/d3-scale-chromatic/index', 'app/core/core', 'app/core/utils/ticks'], function (_export, _context) {
+  "use strict";
+
+  var angular, _, $, d3, d3ScaleChromatic, contextSrv, tickStep, mod, MIN_LEGEND_STEPS;
+
+  function drawColorLegend(elem, colorScheme, rangeFrom, rangeTo, maxValue, minValue) {
+    var legendElem = $(elem).find('svg');
+    var legend = d3.select(legendElem.get(0));
+    clearLegend(elem);
+
+    var legendWidth = Math.floor(legendElem.outerWidth()) - 30;
+    var legendHeight = legendElem.attr("height");
+
+    var rangeStep = 1;
+    if (rangeTo - rangeFrom > legendWidth) {
+      rangeStep = Math.floor((rangeTo - rangeFrom) / legendWidth);
+    }
+
+    if (rangeStep * MIN_LEGEND_STEPS > rangeTo) {
+      rangeStep = rangeTo / MIN_LEGEND_STEPS;
+    }
+
+    var widthFactor = legendWidth / (rangeTo - rangeFrom);
+    var valuesRange = d3.range(rangeFrom, rangeTo, rangeStep);
+
+    var colorScale = getColorScale(colorScheme, maxValue, minValue);
+    legend.selectAll(".status-heatmap-color-legend-rect").data(valuesRange).enter().append("rect").attr("x", function (d) {
+      return d * widthFactor;
+    }).attr("y", 0).attr("width", rangeStep * widthFactor + 1) // Overlap rectangles to prevent gaps
+    .attr("height", legendHeight).attr("stroke-width", 0).attr("fill", function (d) {
+      return colorScale(d);
+    });
+
+    drawLegendValues(elem, colorScale, rangeFrom, rangeTo, maxValue, minValue, legendWidth);
+  }
+
+  function drawOpacityLegend(elem, options, rangeFrom, rangeTo, maxValue, minValue) {
+    var legendElem = $(elem).find('svg');
+    var legend = d3.select(legendElem.get(0));
+    clearLegend(elem);
+
+    var legendWidth = Math.floor(legendElem.outerWidth()) - 30;
+    var legendHeight = legendElem.attr("height");
+
+    var rangeStep = 10;
+    var widthFactor = legendWidth / (rangeTo - rangeFrom);
+
+    if (rangeStep * MIN_LEGEND_STEPS > rangeTo) {
+      rangeStep = rangeTo / MIN_LEGEND_STEPS;
+    }
+
+    var valuesRange = d3.range(rangeFrom, rangeTo, rangeStep);
+
+    var opacityScale = getOpacityScale(options, maxValue, minValue);
+    legend.selectAll(".status-heatmap-opacity-legend-rect").data(valuesRange).enter().append("rect").attr("x", function (d) {
+      return d * widthFactor;
+    }).attr("y", 0).attr("width", rangeStep * widthFactor).attr("height", legendHeight).attr("stroke-width", 0).attr("fill", options.cardColor).style("opacity", function (d) {
+      return opacityScale(d);
+    });
+
+    drawLegendValues(elem, opacityScale, rangeFrom, rangeTo, maxValue, minValue, legendWidth);
+  }
+
+  function drawDiscreteColorLegend(elem, colorOptions, discreteHelper) {
+    var legendElem = $(elem).find('svg');
+    var legend = d3.select(legendElem.get(0));
+    clearLegend(elem);
+
+    var thresholds = colorOptions.thresholds;
+    var tooltips = _.map(thresholds, function (tr) {
+      return tr.tooltip;
+    });
+    var valuesNumber = thresholds.length;
+
+    // graph width as a fallback
+    var $heatmap = $(elem).parent().parent().parent().find('.status-heatmap-panel');
+    var graphWidth = $heatmap.find('svg').attr("width");
+
+    // calculate max width of tooltip and use it as width for each item
+    var textWidth = [];
+    legend.selectAll(".hidden-texts").data(tooltips).enter().append("text").attr("class", "axis tick").attr("font-family", "sans-serif").text(function (d) {
+      return d;
+    }).each(function (d, i) {
+      var thisWidth = this.getBBox().width;
+      textWidth.push(thisWidth);
+      this.remove(); // remove them just after displaying them
+    });
+
+    var legendWidth = Math.floor(_.min([graphWidth - 30, (_.max(textWidth) + 3) * valuesNumber]));
+    legendElem.attr("width", legendWidth);
+
+    var legendHeight = legendElem.attr("height");
+
+    var itemWidth = Math.floor(legendWidth / valuesNumber);
+    var valuesRange = d3.range(valuesNumber); // from 0 to valuesNumber-1
+
+    legend.selectAll(".status-heatmap-color-legend-rect").data(valuesRange).enter().append("rect").attr("x", function (d) {
+      return d * itemWidth;
+    }).attr("y", 0).attr("width", itemWidth + 1) // Overlap rectangles to prevent gaps
+    .attr("height", legendHeight).attr("stroke-width", 0).attr("fill", function (d) {
+      return discreteHelper.getDiscreteColor(d);
+    });
+
+    drawDiscreteLegendValues(elem, colorOptions, legendWidth);
+  }
+
+  function drawLegendValues(elem, colorScale, rangeFrom, rangeTo, maxValue, minValue, legendWidth) {
+    var legendElem = $(elem).find('svg');
+    var legend = d3.select(legendElem.get(0));
+
+    if (legendWidth <= 0 || legendElem.get(0).childNodes.length === 0) {
+      return;
+    }
+
+    var legendValueScale = d3.scaleLinear().domain([0, rangeTo]).range([0, legendWidth]);
+
+    var ticks = buildLegendTicks(0, rangeTo, maxValue, minValue);
+    var xAxis = d3.axisBottom(legendValueScale).tickValues(ticks).tickSize(2);
+
+    var colorRect = legendElem.find(":first-child");
+    var posY = getSvgElemHeight(legendElem) + 2;
+    var posX = getSvgElemX(colorRect);
+
+    d3.select(legendElem.get(0)).append("g").attr("class", "axis").attr("transform", "translate(" + posX + "," + posY + ")").call(xAxis);
+
+    legend.select(".axis").select(".domain").remove();
+  }
+
+  function drawDiscreteLegendValues(elem, colorOptions, legendWidth) {
+    var thresholds = colorOptions.thresholds;
+
+    var legendElem = $(elem).find('svg');
+    var legend = d3.select(legendElem.get(0));
+
+    if (legendWidth <= 0 || legendElem.get(0).childNodes.length === 0) {
+      return;
+    }
+
+    var valuesNumber = thresholds.length;
+    var rangeStep = Math.floor(legendWidth / valuesNumber);
+    var valuesRange = d3.range(0, legendWidth, rangeStep);
+
+    var legendValueScale = d3.scaleLinear().domain([0, valuesNumber]).range([0, legendWidth]);
+
+    var thresholdValues = [];
+    var thresholdTooltips = [];
+    for (var i = 0; i < thresholds.length; i++) {
+      thresholdValues.push(thresholds[i].value);
+      thresholdTooltips.push(thresholds[i].tooltip);
+    }
+
+    var xAxis = d3.axisBottom(legendValueScale).tickValues(d3.range(0, valuesNumber, 1)) //thresholdValues)
+    .tickSize(2).tickFormat(function (t) {
+      var i = Math.floor(t);
+      var v = thresholdTooltips[i];
+      if (v != undefined) {
+        return "" + v;
+      } else {
+        v = thresholdValues[i];
+        if (v != undefined) {
+          return "" + v;
+        } else {
+          return "n/a";
+        }
+      }
+    });
+
+    var colorRect = legendElem.find(":first-child");
+    var posY = getSvgElemHeight(legendElem) + 2;
+    var posX = getSvgElemX(colorRect) + Math.floor(rangeStep / 2);
+
+    d3.select(legendElem.get(0)).append("g").attr("class", "axis").attr("transform", "translate(" + posX + "," + posY + ")").call(xAxis);
+
+    legend.select(".axis").select(".domain").remove();
+  }
+
+  function drawSimpleColorLegend(elem, colorScale) {
+    var legendElem = $(elem).find('svg');
+    clearLegend(elem);
+
+    var legendWidth = Math.floor(legendElem.outerWidth());
+    var legendHeight = legendElem.attr("height");
+
+    if (legendWidth) {
+      var valuesNumber = Math.floor(legendWidth / 2);
+      var rangeStep = Math.floor(legendWidth / valuesNumber);
+      var valuesRange = d3.range(0, legendWidth, rangeStep);
+
+      var legend = d3.select(legendElem.get(0));
+      var legendRects = legend.selectAll(".status-heatmap-color-legend-rect").data(valuesRange);
+
+      legendRects.enter().append("rect").attr("x", function (d) {
+        return d;
+      }).attr("y", 0).attr("width", rangeStep + 1) // Overlap rectangles to prevent gaps
+      .attr("height", legendHeight).attr("stroke-width", 0).attr("fill", function (d) {
+        return colorScale(d);
+      });
+    }
+  }
+
+  function drawSimpleOpacityLegend(elem, options) {
+    var legendElem = $(elem).find('svg');
+    var graphElem = $(elem);
+    clearLegend(elem);
+
+    var legend = d3.select(legendElem.get(0));
+    var legendWidth = Math.floor(legendElem.outerWidth());
+    var legendHeight = legendElem.attr("height");
+
+    if (legendWidth) {
+      var legendOpacityScale = void 0;
+      if (options.colorScale === 'linear') {
+        legendOpacityScale = d3.scaleLinear().domain([0, legendWidth]).range([0, 1]);
+      } else if (options.colorScale === 'sqrt') {
+        legendOpacityScale = d3.scalePow().exponent(options.exponent).domain([0, legendWidth]).range([0, 1]);
+      }
+
+      var rangeStep = 10;
+      var valuesRange = d3.range(0, legendWidth, rangeStep);
+      var legendRects = legend.selectAll(".status-heatmap-opacity-legend-rect").data(valuesRange);
+
+      legendRects.enter().append("rect").attr("x", function (d) {
+        return d;
+      }).attr("y", 0).attr("width", rangeStep).attr("height", legendHeight).attr("stroke-width", 0).attr("fill", options.cardColor).style("opacity", function (d) {
+        return legendOpacityScale(d);
+      });
+    }
+  }
+
+  function clearLegend(elem) {
+    var legendElem = $(elem).find('svg');
+    legendElem.empty();
+  }
+
+  function getColorScale(colorScheme, maxValue) {
+    var minValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+
+    var colorInterpolator = d3ScaleChromatic[colorScheme.value];
+    var colorScaleInverted = colorScheme.invert === 'always' || colorScheme.invert === 'dark' && !contextSrv.user.lightTheme;
+
+    var start = colorScaleInverted ? maxValue : minValue;
+    var end = colorScaleInverted ? minValue : maxValue;
+
+    return d3.scaleSequential(colorInterpolator).domain([start, end]);
+  }
+
+  function getOpacityScale(options, maxValue) {
+    var minValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+
+    var legendOpacityScale = void 0;
+    if (options.colorScale === 'linear') {
+      legendOpacityScale = d3.scaleLinear().domain([minValue, maxValue]).range([0, 1]);
+    } else if (options.colorScale === 'sqrt') {
+      legendOpacityScale = d3.scalePow().exponent(options.exponent).domain([minValue, maxValue]).range([0, 1]);
+    }
+    return legendOpacityScale;
+  }
+
+  function getSvgElemX(elem) {
+    var svgElem = elem.get(0);
+    if (svgElem && svgElem.x && svgElem.x.baseVal) {
+      return svgElem.x.baseVal.value;
+    } else {
+      return 0;
+    }
+  }
+
+  function getSvgElemHeight(elem) {
+    var svgElem = elem.get(0);
+    if (svgElem && svgElem.height && svgElem.height.baseVal) {
+      return svgElem.height.baseVal.value;
+    } else {
+      return 0;
+    }
+  }
+
+  function buildLegendTicks(rangeFrom, rangeTo, maxValue, minValue) {
+    var range = rangeTo - rangeFrom;
+    var tickStepSize = tickStep(rangeFrom, rangeTo, 3);
+    var ticksNum = Math.round(range / tickStepSize);
+    var ticks = [];
+
+    for (var i = 0; i < ticksNum; i++) {
+      var current = tickStepSize * i;
+      // Add user-defined min and max if it had been set
+      if (isValueCloseTo(minValue, current, tickStepSize)) {
+        ticks.push(minValue);
+        continue;
+      } else if (minValue < current) {
+        ticks.push(minValue);
+      }
+      if (isValueCloseTo(maxValue, current, tickStepSize)) {
+        ticks.push(maxValue);
+        continue;
+      } else if (maxValue < current) {
+        ticks.push(maxValue);
+      }
+      ticks.push(tickStepSize * i);
+    }
+    if (!isValueCloseTo(maxValue, rangeTo, tickStepSize)) {
+      ticks.push(maxValue);
+    }
+    ticks.push(rangeTo);
+    ticks = _.sortBy(_.uniq(ticks));
+    return ticks;
+  }
+
+  function isValueCloseTo(val, valueTo, step) {
+    var diff = Math.abs(val - valueTo);
+    return diff < step * 0.3;
+  }
+  return {
+    setters: [function (_angular) {
+      angular = _angular.default;
+    }, function (_lodash) {
+      _ = _lodash.default;
+    }, function (_jquery) {
+      $ = _jquery.default;
+    }, function (_d) {
+      d3 = _d.default;
+    }, function (_libsD3ScaleChromaticIndex) {
+      d3ScaleChromatic = _libsD3ScaleChromaticIndex;
+    }, function (_appCoreCore) {
+      contextSrv = _appCoreCore.contextSrv;
+    }, function (_appCoreUtilsTicks) {
+      tickStep = _appCoreUtilsTicks.tickStep;
+    }],
+    execute: function () {
+      mod = angular.module('grafana.directives');
+      MIN_LEGEND_STEPS = 10;
+
+
+      /**
+       * Color legend for heatmap editor.
+       */
+      mod.directive('optionsColorLegend', function () {
+        return {
+          restrict: 'E',
+          template: '<div class="status-heatmap-color-legend"><svg width="16.8rem" height="24px"></svg></div>',
+          link: function link(scope, elem, attrs) {
+            var ctrl = scope.ctrl;
+            var panel = scope.ctrl.panel;
+
+            render();
+
+            ctrl.events.on('render', function () {
+              render();
+            });
+
+            function render() {
+              var legendElem = $(elem).find('svg');
+              var legendWidth = Math.floor(legendElem.outerWidth());
+
+              if (panel.color.mode === 'spectrum') {
+                var colorScheme = _.find(ctrl.colorSchemes, { value: panel.color.colorScheme });
+                var colorScale = getColorScale(colorScheme, legendWidth);
+                drawSimpleColorLegend(elem, colorScale);
+              } else if (panel.color.mode === 'opacity') {
+                var colorOptions = panel.color;
+                drawSimpleOpacityLegend(elem, colorOptions);
+              }
+            }
+          }
+        };
+      });
+
+      /**
+       * Heatmap legend with scale values.
+       */
+      mod.directive('statusHeatmapLegend', function () {
+        return {
+          restrict: 'E',
+          template: '<div class="status-heatmap-color-legend"><svg width="100px" height="6px"></svg></div>',
+          link: function link(scope, elem, attrs) {
+            var ctrl = scope.ctrl;
+            var panel = scope.ctrl.panel;
+
+            render();
+            ctrl.events.on('render', function () {
+              render();
+            });
+
+            function render() {
+              clearLegend(elem);
+              if (!_.isEmpty(ctrl.cardsData) && !_.isEmpty(ctrl.cardsData.cards)) {
+                var rangeFrom = ctrl.cardsData.minValue;
+                var rangeTo = ctrl.cardsData.maxValue;
+                var maxValue = panel.color.max || rangeTo;
+                var minValue = panel.color.min || rangeFrom;
+
+                if (panel.color.mode === 'spectrum') {
+                  var colorScheme = _.find(ctrl.colorSchemes, { value: panel.color.colorScheme });
+                  drawColorLegend(elem, colorScheme, rangeFrom, rangeTo, maxValue, minValue);
+                } else if (panel.color.mode === 'opacity') {
+                  var colorOptions = panel.color;
+                  drawOpacityLegend(elem, colorOptions, rangeFrom, rangeTo, maxValue, minValue);
+                } else if (panel.color.mode === 'discrete') {
+                  var _colorOptions = panel.color;
+                  drawDiscreteColorLegend(elem, _colorOptions, ctrl.discreteHelper);
+                }
+              }
+            }
+          }
+        };
+      });
+    }
+  };
+});
+//# sourceMappingURL=color_legend.js.map

dist/color_mode_discrete.js

@@ -0,0 +1,245 @@
+"use strict";
+
+System.register(["lodash"], function (_export, _context) {
+  "use strict";
+
+  var _, _createClass, ColorModeDiscrete;
+
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+
+  return {
+    setters: [function (_lodash) {
+      _ = _lodash.default;
+    }],
+    execute: function () {
+      _createClass = function () {
+        function defineProperties(target, props) {
+          for (var i = 0; i < props.length; i++) {
+            var descriptor = props[i];
+            descriptor.enumerable = descriptor.enumerable || false;
+            descriptor.configurable = true;
+            if ("value" in descriptor) descriptor.writable = true;
+            Object.defineProperty(target, descriptor.key, descriptor);
+          }
+        }
+
+        return function (Constructor, protoProps, staticProps) {
+          if (protoProps) defineProperties(Constructor.prototype, protoProps);
+          if (staticProps) defineProperties(Constructor, staticProps);
+          return Constructor;
+        };
+      }();
+
+      _export("ColorModeDiscrete", ColorModeDiscrete = function () {
+        function ColorModeDiscrete(scope) {
+          _classCallCheck(this, ColorModeDiscrete);
+
+          this.scope = scope;
+          this.panelCtrl = scope.ctrl;
+          this.panel = scope.ctrl.panel;
+        }
+
+        // get tooltip for each value ordered by thresholds priority
+
+
+        _createClass(ColorModeDiscrete, [{
+          key: "convertValuesToTooltips",
+          value: function convertValuesToTooltips(values) {
+            var thresholds = this.panel.color.thresholds;
+            var tooltips = [];
+
+            for (var i = 0; i < thresholds.length; i++) {
+              for (var j = 0; j < values.length; j++) {
+                if (values[j] == thresholds[i].value) {
+                  tooltips.push({
+                    "tooltip": thresholds[i].tooltip ? thresholds[i].tooltip : values[j],
+                    "color": thresholds[i].color
+                  });
+                }
+              }
+            }
+            return tooltips;
+          }
+        }, {
+          key: "getNotMatchedValues",
+          value: function getNotMatchedValues(values) {
+            var notMatched = [];
+            for (var j = 0; j < values.length; j++) {
+              if (!this.getMatchedThreshold(values[j])) {
+                notMatched.push(values[j]);
+              }
+            }
+            return notMatched;
+          }
+        }, {
+          key: "getNotColoredValues",
+          value: function getNotColoredValues(values) {
+            var notMatched = [];
+            for (var j = 0; j < values.length; j++) {
+              var threshold = this.getMatchedThreshold(values[j]);
+              if (!threshold || !threshold.color || threshold.color == "") {
+                notMatched.push(values[j]);
+              }
+            }
+            return notMatched;
+          }
+        }, {
+          key: "getDiscreteColor",
+          value: function getDiscreteColor(index) {
+            var color = this.getThreshold(index).color;
+            if (!color || color == "") {
+              return 'rgba(0,0,0,1)';
+            }
+            return color;
+          }
+        }, {
+          key: "getBucketColor",
+          value: function getBucketColor(values) {
+            var thresholds = this.panel.color.thresholds;
+
+            for (var i = 0; i < thresholds.length; i++) {
+              for (var j = 0; j < values.length; j++) {
+                if (values[j] == thresholds[i].value) {
+                  return this.getDiscreteColor(i);
+                }
+              }
+            }
+            return 'rgba(0,0,0,1)';
+          }
+        }, {
+          key: "updateCardsValuesHasColorInfo",
+          value: function updateCardsValuesHasColorInfo() {
+            if (!this.panelCtrl.cardsData) {
+              return;
+            }
+            this.panelCtrl.cardsData.noColorDefined = false;
+            var cards = this.panelCtrl.cardsData.cards;
+            for (var i = 0; i < cards.length; i++) {
+              cards[i].noColorDefined = false;
+              var values = cards[i].values;
+              for (var j = 0; j < values.length; j++) {
+                var threshold = this.getMatchedThreshold(values[j]);
+                if (!threshold || !threshold.color || threshold.color == "") {
+                  cards[i].noColorDefined = true;
+                  this.panelCtrl.cardsData.noColorDefined = true;
+                  break;
+                }
+              }
+            }
+          }
+        }, {
+          key: "getMatchedThreshold",
+          value: function getMatchedThreshold(value) {
+            if (value == null) {
+              if (this.panel.color.nullPointMode == 'as empty') {
+                // FIXME: make this explicit for user
+                // Right now this color never used because null as empty handles in getCardOpacity method.
+                return {
+                  "color": "rgba(0,0,0,0)",
+                  "value": "null",
+                  "tooltip": "null"
+                };
+              } else {
+                value = 0;
+              }
+            }
+
+            var thresholds = this.panel.color.thresholds;
+            for (var k = 0; k < thresholds.length; k++) {
+              if (value == thresholds[k].value) {
+                return thresholds[k];
+              }
+            }
+            return null;
+          }
+        }, {
+          key: "getThreshold",
+          value: function getThreshold(index) {
+            var thresholds = this.panel.color.thresholds;
+            if (index < 0 || index >= thresholds.length == null) {
+              return {
+                "color": "rgba(0,0,0,0)",
+                "value": "null",
+                "tooltip": "null"
+              };
+            }
+            return thresholds[index];
+          }
+        }, {
+          key: "roundIntervalCeil",
+          value: function roundIntervalCeil(interval) {
+            switch (true) {
+              case interval <= 10:
+                return 10; // 0.01s
+              case interval <= 20:
+                return 20; // 0.02s
+              case interval <= 50:
+                return 50; // 0.05s
+              case interval <= 100:
+                return 100; // 0.1s
+              case interval <= 200:
+                return 200; // 0.2s
+              case interval <= 500:
+                return 500; // 0.5s
+              case interval <= 1000:
+                return 1000; // 1s
+              case interval <= 2000:
+                return 2000; // 2s
+              case interval <= 5000:
+                return 5000; // 5s
+              case interval <= 10000:
+                return 10000; // 10s
+              case interval <= 15000:
+                return 15000; // 15s
+              case interval <= 20000:
+                return 20000; // 20s
+              case interval <= 30000:
+                return 30000; // 30s
+              case interval <= 60000:
+                return 60000; // 1m
+              case interval <= 120000:
+                return 120000; // 2m
+              case interval <= 300000:
+                return 300000; // 5m
+              case interval <= 600000:
+                return 600000; // 10m
+              case interval <= 900000:
+                return 900000; // 15m
+              case interval <= 1200000:
+                return 1200000; // 20m
+              case interval <= 1800000:
+                return 1800000; // 30m
+              case interval <= 3600000:
+                return 3600000; // 1h
+              case interval <= 7200000:
+                return 7200000; // 2h
+              case interval <= 10800000:
+                return 10800000; // 3h
+              case interval <= 21600000:
+                return 21600000; // 6h
+              case interval <= 43200000:
+                return 43200000; // 12h
+              case interval <= 86400000:
+                return 86400000; // 1d
+              case interval <= 604800000:
+                return 604800000; // 1w
+              case interval <= 2592000000:
+                return 2592000000; // 30d
+              default:
+                return 31536000000; // 1y
+            }
+          }
+        }]);
+
+        return ColorModeDiscrete;
+      }());
+
+      _export("ColorModeDiscrete", ColorModeDiscrete);
+    }
+  };
+});
+//# sourceMappingURL=color_mode_discrete.js.map

dist/css/status-heatmap.css

@@ -0,0 +1,60 @@
+.status-heatmap-canvas-wrapper {
+  cursor: crosshair; }
+  .status-heatmap-canvas-wrapper .datapoints-warning span {
+    background-color: white;
+    padding: 1px; }
+
+.status-heatmap-panel {
+  position: relative; }
+  .status-heatmap-panel .axis .tick text {
+    fill: #52545c;
+    color: #52545c;
+    font-size: 11px; }
+  .status-heatmap-panel .axis .tick line {
+    opacity: 0.4;
+    stroke: #767980; }
+  .status-heatmap-panel svg {
+    pointer-events: none; }
+    .status-heatmap-panel svg rect {
+      pointer-events: visiblePainted; }
+
+.status-heatmap-tooltip {
+  white-space: nowrap;
+  font-size: 12px;
+  background-color: #dde4ed;
+  color: #52545c; }
+
+.status-heatmap-histogram rect {
+  fill: #767980; }
+
+.status-heatmap-crosshair line {
+  stroke: #b30000;
+  stroke-width: 1; }
+
+.status-heatmap-selection {
+  stroke-width: 1;
+  fill: rgba(102, 102, 102, 0.4);
+  stroke: rgba(102, 102, 102, 0.8); }
+
+.status-heatmap-legend-wrapper {
+  margin: 0 10px; }
+  .status-heatmap-legend-wrapper svg {
+    height: 24px;
+    float: left;
+    white-space: nowrap; }
+  .status-heatmap-legend-wrapper .status-heatmap-color-legend {
+    margin-top: 4px; }
+  .status-heatmap-legend-wrapper .status-heatmap-legend-values {
+    display: inline-block; }
+  .status-heatmap-legend-wrapper .axis .tick text {
+    fill: #52545c;
+    color: #52545c;
+    font-size: 11px; }
+  .status-heatmap-legend-wrapper .axis .tick line {
+    opacity: 0.4;
+    stroke: #767980; }
+  .status-heatmap-legend-wrapper .axis .tick .domain {
+    opacity: 0.4;
+    stroke: #767980; }
+
+/*# sourceMappingURL=status-heatmap.css.map */

dist/css/status-heatmap.css.map

@@ -0,0 +1,7 @@
+{
+"version": 3,
+"mappings": "AAGA,8BAA+B;EAE7B,MAAM,EAAE,SAAS;EAEjB,uDAAyB;IACzB,gBAAgB,EAAE,KAAK;IACvB,OAAO,EAAE,GAAG;;AAId,qBAAsB;EACpB,QAAQ,EAAE,QAAQ;EAGhB,sCAAK;IACH,IAAI,EAAE,OAAO;IACb,KAAK,EAAE,OAAO;IACd,SAAS,EAAE,IAAI;EAGjB,sCAAK;IACH,OAAO,EAAE,GAAG;IACZ,MAAM,EAAE,OAAO;EAKnB,yBAAI;IACF,cAAc,EAAE,IAAI;IAEpB,8BAAK;MACH,cAAc,EAAE,cAAc;;AAKpC,uBAAwB;EACtB,WAAW,EAAE,MAAM;EACnB,SAAS,EAzCI,IAAI;EA0CjB,gBAAgB,EAAE,OAAO;EACzB,KAAK,EAAE,OAAO;;AAGhB,8BAA+B;EAC7B,IAAI,EAAE,OAAO;;AAIb,8BAAK;EACH,MAAM,EAAE,OAAe;EACvB,YAAY,EAAE,CAAC;;AAInB,yBAA0B;EACxB,YAAY,EAAE,CAAC;EACf,IAAI,EAAE,wBAAwB;EAC9B,MAAM,EAAE,wBAAwB;;AAGlC,8BAA+B;EAE7B,MAAM,EAAE,MAAM;EAGd,kCAAI;IAGF,MAAM,EAAE,IAAI;IACZ,KAAK,EAAE,IAAI;IACX,WAAW,EAAE,MAAM;EAIrB,2DAA6B;IAC3B,UAAU,EAAE,GAAG;EAGjB,4DAA8B;IAC5B,OAAO,EAAE,YAAY;EAIrB,+CAAK;IACH,IAAI,EAAE,OAAO;IACb,KAAK,EAAE,OAAO;IACd,SAAS,EAAE,IAAI;EAGjB,+CAAK;IACH,OAAO,EAAE,GAAG;IACZ,MAAM,EAAE,OAAO;EAGjB,kDAAQ;IACN,OAAO,EAAE,GAAG;IACZ,MAAM,EAAE,OAAO",
+"sources": ["../../src/css/status-heatmap.scss"],
+"names": [],
+"file": "status-heatmap.css"
+}

dist/img/logo.svg

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Generator: Adobe Illustrator 20.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 100 100" xml:space="preserve" height="100px" viewBox="0 0 100 100" width="100px" version="1.1" y="0px" x="0px" xmlns:cc="http://creativecommons.org/ns#" xmlns:dc="http://purl.org/dc/elements/1.1/"><rect height="100" width="100" y="-5.44e-15" x="0"/><g fill="#008000"><rect height="22.5" width="10.4" y="1.4" x="38.4"/><rect height="22.5" width="10.4" y="26.3" x="38.4"/><rect height="22.4" width="10.4" y="76.1" x="38.4"/><rect height="22.3" width="10.4" y="51.2" x="38.4"/><rect height="22.5" width="10.4" y="1.4" x="50.9"/><rect height="22.5" width="10.4" y="76" x="50.9"/></g><rect height="22.3" width="10.4" y="51.2" x="50.9" fill="#ff0"/><rect height="22.5" width="10.4" y="1.4" x="63.3" fill="#f00"/><g fill="#008000"><rect height="22.5" width="10.4" y="26.3" x="63.3"/><rect height="22.5" width="10.4" y="26.3" x="50.8"/><rect height="22.5" width="10.4" y="76" x="63.3"/><rect height="22.3" width="10.4" y="51.2" x="63.3"/></g><rect height="22.5" width="10.4" y="1.4" x="75.7" fill="#f00"/><g fill="#008000"><rect height="22.5" width="10.4" y="26.3" x="75.7"/><rect height="22.5" width="10.4" y="76" x="75.7"/><rect height="22.4" width="10.4" y="51.2" x="75.7"/><rect height="22.5" width="10.4" y="26.3" x="88.2"/><rect height="22.5" width="10.4" y="76" x="88.2"/><rect height="22.3" width="10.4" y="51.2" x="88.2"/><rect height="22.5" width="10.4" y="1.4" x="88.2"/></g><g fill-rule="evenodd" fill="#999"><path d="m32.3 35.8h3.56v3.55h-1.8v-1.78h-1.77z"/><path d="m26.9 37.6h1.77v-1.77h1.8v5.33h-1.8v-1.78h-1.77z"/><path d="m23.3 37.6h1.8v3.56h-1.8z"/><path d="m18 41.1h3.56v-5.33h-1.8v1.77h-1.77z"/><path d="m24.4 60h3.56v3.55h-1.8v-1.78h-1.77z"/><path d="m13.7 61.8h1.77v-1.77h1.8v5.33h-1.8v-1.78h-1.77z"/><path d="m33.5 61.8h1.8v3.56h-1.8z"/><path d="m19.1 65.4h3.56v-5.33h-1.8v1.77h-1.77z"/><path d="m29.8 60h1.77v5.33h-1.77z"/><path d="m3.09 63.6h1.77v1.78h1.8v-5.33h-1.8v1.77h-1.77z"/><path d="m8.25 60h1.77v3.55h-1.77z"/><path d="m10 65.4h1.8v-1.78h-1.8v1.78z"/><path d="m32.3 86h3.56v3.55h-1.8v-1.78h-1.77z"/><path d="m26.2 87.8h1.77v-1.77h1.8v5.33h-1.8v-1.78h-1.77z"/><path d="m22.3 87.8h1.8v3.56h-1.8z"/><path d="m12.6 86h1.77v5.33h-1.77z"/><path d="m16.7 89.6h1.77v1.78h1.8v-5.33h-1.8v1.77h-1.77z"/><path d="m7.65 86h1.77v3.55h-1.77z"/><path d="m9.42 91.4h1.8v-1.78h-1.8v1.78z"/><path d="m2.2 9.8h3.56v3.55h-1.8v-1.78h-1.77z"/><path d="m26.9 11.6h1.77v-1.77h1.8v5.33h-1.8v-1.78h-1.77z"/><path d="m22.6 11.6h1.8v3.56h-1.8z"/><path d="m12.8 15.1h3.56v-5.33h-1.8v1.77h-1.77z"/><path d="m18.3 9.8h1.77v5.33h-1.77z"/><path d="m7.26 13.3h1.77v1.78h1.8v-5.33h-1.8v1.77h-1.77z"/><path d="m32.3 9.8h1.77v3.55h-1.77z"/><path d="m34.1 15.1h1.8v-1.78h-1.8v1.78z"/></g></svg>

dist/libs/d3-scale-chromatic/categorical/Accent.js

@@ -0,0 +1,16 @@
+"use strict";
+
+System.register(["../colors"], function (_export, _context) {
+  "use strict";
+
+  var colors;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }],
+    execute: function () {
+      _export("default", colors("7fc97fbeaed4fdc086ffff99386cb0f0027fbf5b17666666"));
+    }
+  };
+});
+//# sourceMappingURL=Accent.js.map

dist/libs/d3-scale-chromatic/categorical/Accent.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/categorical/Accent.js"],"names":["colors"],"mappings":";;;;;;;;AAAOA,Y;;;yBAEQA,OAAO,kDAAP,C","file":"Accent.js","sourcesContent":["import colors from \"../colors\";\n\nexport default colors(\"7fc97fbeaed4fdc086ffff99386cb0f0027fbf5b17666666\");\n"]}

dist/libs/d3-scale-chromatic/categorical/Dark2.js

@@ -0,0 +1,16 @@
+"use strict";
+
+System.register(["../colors"], function (_export, _context) {
+  "use strict";
+
+  var colors;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }],
+    execute: function () {
+      _export("default", colors("1b9e77d95f027570b3e7298a66a61ee6ab02a6761d666666"));
+    }
+  };
+});
+//# sourceMappingURL=Dark2.js.map

dist/libs/d3-scale-chromatic/categorical/Dark2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/categorical/Dark2.js"],"names":["colors"],"mappings":";;;;;;;;AAAOA,Y;;;yBAEQA,OAAO,kDAAP,C","file":"Dark2.js","sourcesContent":["import colors from \"../colors\";\n\nexport default colors(\"1b9e77d95f027570b3e7298a66a61ee6ab02a6761d666666\");\n"]}

dist/libs/d3-scale-chromatic/categorical/Paired.js

@@ -0,0 +1,16 @@
+"use strict";
+
+System.register(["../colors"], function (_export, _context) {
+  "use strict";
+
+  var colors;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }],
+    execute: function () {
+      _export("default", colors("a6cee31f78b4b2df8a33a02cfb9a99e31a1cfdbf6fff7f00cab2d66a3d9affff99b15928"));
+    }
+  };
+});
+//# sourceMappingURL=Paired.js.map

dist/libs/d3-scale-chromatic/categorical/Paired.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/categorical/Paired.js"],"names":["colors"],"mappings":";;;;;;;;AAAOA,Y;;;yBAEQA,OAAO,0EAAP,C","file":"Paired.js","sourcesContent":["import colors from \"../colors\";\n\nexport default colors(\"a6cee31f78b4b2df8a33a02cfb9a99e31a1cfdbf6fff7f00cab2d66a3d9affff99b15928\");\n"]}

dist/libs/d3-scale-chromatic/categorical/Pastel1.js

@@ -0,0 +1,16 @@
+"use strict";
+
+System.register(["../colors"], function (_export, _context) {
+  "use strict";
+
+  var colors;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }],
+    execute: function () {
+      _export("default", colors("fbb4aeb3cde3ccebc5decbe4fed9a6ffffcce5d8bdfddaecf2f2f2"));
+    }
+  };
+});
+//# sourceMappingURL=Pastel1.js.map

dist/libs/d3-scale-chromatic/categorical/Pastel1.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/categorical/Pastel1.js"],"names":["colors"],"mappings":";;;;;;;;AAAOA,Y;;;yBAEQA,OAAO,wDAAP,C","file":"Pastel1.js","sourcesContent":["import colors from \"../colors\";\n\nexport default colors(\"fbb4aeb3cde3ccebc5decbe4fed9a6ffffcce5d8bdfddaecf2f2f2\");\n"]}

dist/libs/d3-scale-chromatic/categorical/Pastel2.js

@@ -0,0 +1,16 @@
+"use strict";
+
+System.register(["../colors"], function (_export, _context) {
+  "use strict";
+
+  var colors;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }],
+    execute: function () {
+      _export("default", colors("b3e2cdfdcdaccbd5e8f4cae4e6f5c9fff2aef1e2cccccccc"));
+    }
+  };
+});
+//# sourceMappingURL=Pastel2.js.map

dist/libs/d3-scale-chromatic/categorical/Pastel2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/categorical/Pastel2.js"],"names":["colors"],"mappings":";;;;;;;;AAAOA,Y;;;yBAEQA,OAAO,kDAAP,C","file":"Pastel2.js","sourcesContent":["import colors from \"../colors\";\n\nexport default colors(\"b3e2cdfdcdaccbd5e8f4cae4e6f5c9fff2aef1e2cccccccc\");\n"]}

dist/libs/d3-scale-chromatic/categorical/Set1.js

@@ -0,0 +1,16 @@
+"use strict";
+
+System.register(["../colors"], function (_export, _context) {
+  "use strict";
+
+  var colors;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }],
+    execute: function () {
+      _export("default", colors("e41a1c377eb84daf4a984ea3ff7f00ffff33a65628f781bf999999"));
+    }
+  };
+});
+//# sourceMappingURL=Set1.js.map

dist/libs/d3-scale-chromatic/categorical/Set1.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/categorical/Set1.js"],"names":["colors"],"mappings":";;;;;;;;AAAOA,Y;;;yBAEQA,OAAO,wDAAP,C","file":"Set1.js","sourcesContent":["import colors from \"../colors\";\n\nexport default colors(\"e41a1c377eb84daf4a984ea3ff7f00ffff33a65628f781bf999999\");\n"]}

dist/libs/d3-scale-chromatic/categorical/Set2.js

@@ -0,0 +1,16 @@
+"use strict";
+
+System.register(["../colors"], function (_export, _context) {
+  "use strict";
+
+  var colors;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }],
+    execute: function () {
+      _export("default", colors("66c2a5fc8d628da0cbe78ac3a6d854ffd92fe5c494b3b3b3"));
+    }
+  };
+});
+//# sourceMappingURL=Set2.js.map

dist/libs/d3-scale-chromatic/categorical/Set2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/categorical/Set2.js"],"names":["colors"],"mappings":";;;;;;;;AAAOA,Y;;;yBAEQA,OAAO,kDAAP,C","file":"Set2.js","sourcesContent":["import colors from \"../colors\";\n\nexport default colors(\"66c2a5fc8d628da0cbe78ac3a6d854ffd92fe5c494b3b3b3\");\n"]}

dist/libs/d3-scale-chromatic/categorical/Set3.js

@@ -0,0 +1,16 @@
+"use strict";
+
+System.register(["../colors"], function (_export, _context) {
+  "use strict";
+
+  var colors;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }],
+    execute: function () {
+      _export("default", colors("8dd3c7ffffb3bebadafb807280b1d3fdb462b3de69fccde5d9d9d9bc80bdccebc5ffed6f"));
+    }
+  };
+});
+//# sourceMappingURL=Set3.js.map

dist/libs/d3-scale-chromatic/categorical/Set3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/categorical/Set3.js"],"names":["colors"],"mappings":";;;;;;;;AAAOA,Y;;;yBAEQA,OAAO,0EAAP,C","file":"Set3.js","sourcesContent":["import colors from \"../colors\";\n\nexport default colors(\"8dd3c7ffffb3bebadafb807280b1d3fdb462b3de69fccde5d9d9d9bc80bdccebc5ffed6f\");\n"]}

dist/libs/d3-scale-chromatic/colors.js

@@ -0,0 +1,20 @@
+"use strict";
+
+System.register([], function (_export, _context) {
+  "use strict";
+
+  _export("default", function (specifier) {
+    var n = specifier.length / 6 | 0,
+        colors = new Array(n),
+        i = 0;
+    while (i < n) {
+      colors[i] = "#" + specifier.slice(i * 6, ++i * 6);
+    }return colors;
+  });
+
+  return {
+    setters: [],
+    execute: function () {}
+  };
+});
+//# sourceMappingURL=colors.js.map

dist/libs/d3-scale-chromatic/colors.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/libs/d3-scale-chromatic/colors.js"],"names":["specifier","n","length","colors","Array","i","slice"],"mappings":";;;;;qBAAe,UAASA,SAAT,EAAoB;AACjC,QAAIC,IAAID,UAAUE,MAAV,GAAmB,CAAnB,GAAuB,CAA/B;AAAA,QAAkCC,SAAS,IAAIC,KAAJ,CAAUH,CAAV,CAA3C;AAAA,QAAyDI,IAAI,CAA7D;AACA,WAAOA,IAAIJ,CAAX;AAAcE,aAAOE,CAAP,IAAY,MAAML,UAAUM,KAAV,CAAgBD,IAAI,CAApB,EAAuB,EAAEA,CAAF,GAAM,CAA7B,CAAlB;AAAd,KACA,OAAOF,MAAP;AACD,G","file":"colors.js","sourcesContent":["export default function(specifier) {\n  var n = specifier.length / 6 | 0, colors = new Array(n), i = 0;\n  while (i < n) colors[i] = \"#\" + specifier.slice(i * 6, ++i * 6);\n  return colors;\n}\n"]}

dist/libs/d3-scale-chromatic/diverging/BrBG.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("d8b365f5f5f55ab4ac", "a6611adfc27d80cdc1018571", "a6611adfc27df5f5f580cdc1018571", "8c510ad8b365f6e8c3c7eae55ab4ac01665e", "8c510ad8b365f6e8c3f5f5f5c7eae55ab4ac01665e", "8c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e", "8c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e", "5430058c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e003c30", "5430058c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e003c30").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=BrBG.js.map

dist/libs/d3-scale-chromatic/diverging/BrBG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/diverging/BrBG.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlB,8DARkB,EASlB,oEATkB,EAUlBC,GAVkB,CAUdL,MAVc,C;;;;yBAYLC,KAAKC,MAAL,C","file":"BrBG.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"d8b365f5f5f55ab4ac\",\n  \"a6611adfc27d80cdc1018571\",\n  \"a6611adfc27df5f5f580cdc1018571\",\n  \"8c510ad8b365f6e8c3c7eae55ab4ac01665e\",\n  \"8c510ad8b365f6e8c3f5f5f5c7eae55ab4ac01665e\",\n  \"8c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e\",\n  \"8c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e\",\n  \"5430058c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e003c30\",\n  \"5430058c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e003c30\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/diverging/GnYlRd.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("91cf60ffffbffc8d59", "1a9641a6d96afdae61d7191c", "1a9641a6d96affffbffdae61d7191c", "1a985091cf60d9ef8bfee08bfc8d59d73027", "1a985091cf60d9ef8bffffbffee08bfc8d59d73027", "1a985066bd63a6d96ad9ef8bfee08bfdae61f46d43d73027", "1a985066bd63a6d96ad9ef8bffffbffee08bfdae61f46d43d73027", "0068371a985066bd63a6d96ad9ef8bfee08bfdae61f46d43d73027a50026", "0068371a985066bd63a6d96ad9ef8bffffbffee08bfdae61f46d43d73027a50026").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=GnYlRd.js.map

dist/libs/d3-scale-chromatic/diverging/GnYlRd.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/diverging/GnYlRd.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlB,8DARkB,EASlB,oEATkB,EAUlBC,GAVkB,CAUdL,MAVc,C;;;;yBAYLC,KAAKC,MAAL,C","file":"GnYlRd.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"91cf60ffffbffc8d59\",\n  \"1a9641a6d96afdae61d7191c\",\n  \"1a9641a6d96affffbffdae61d7191c\",\n  \"1a985091cf60d9ef8bfee08bfc8d59d73027\",\n  \"1a985091cf60d9ef8bffffbffee08bfc8d59d73027\",\n  \"1a985066bd63a6d96ad9ef8bfee08bfdae61f46d43d73027\",\n  \"1a985066bd63a6d96ad9ef8bffffbffee08bfdae61f46d43d73027\",\n  \"0068371a985066bd63a6d96ad9ef8bfee08bfdae61f46d43d73027a50026\",\n  \"0068371a985066bd63a6d96ad9ef8bffffbffee08bfdae61f46d43d73027a50026\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/diverging/PRGn.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("af8dc3f7f7f77fbf7b", "7b3294c2a5cfa6dba0008837", "7b3294c2a5cff7f7f7a6dba0008837", "762a83af8dc3e7d4e8d9f0d37fbf7b1b7837", "762a83af8dc3e7d4e8f7f7f7d9f0d37fbf7b1b7837", "762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b7837", "762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b7837", "40004b762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b783700441b", "40004b762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b783700441b").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=PRGn.js.map

dist/libs/d3-scale-chromatic/diverging/PRGn.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/diverging/PRGn.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlB,8DARkB,EASlB,oEATkB,EAUlBC,GAVkB,CAUdL,MAVc,C;;;;yBAYLC,KAAKC,MAAL,C","file":"PRGn.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"af8dc3f7f7f77fbf7b\",\n  \"7b3294c2a5cfa6dba0008837\",\n  \"7b3294c2a5cff7f7f7a6dba0008837\",\n  \"762a83af8dc3e7d4e8d9f0d37fbf7b1b7837\",\n  \"762a83af8dc3e7d4e8f7f7f7d9f0d37fbf7b1b7837\",\n  \"762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b7837\",\n  \"762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b7837\",\n  \"40004b762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b783700441b\",\n  \"40004b762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b783700441b\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/diverging/PiYG.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("e9a3c9f7f7f7a1d76a", "d01c8bf1b6dab8e1864dac26", "d01c8bf1b6daf7f7f7b8e1864dac26", "c51b7de9a3c9fde0efe6f5d0a1d76a4d9221", "c51b7de9a3c9fde0eff7f7f7e6f5d0a1d76a4d9221", "c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221", "c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221", "8e0152c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221276419", "8e0152c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221276419").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=PiYG.js.map

dist/libs/d3-scale-chromatic/diverging/PiYG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/diverging/PiYG.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlB,8DARkB,EASlB,oEATkB,EAUlBC,GAVkB,CAUdL,MAVc,C;;;;yBAYLC,KAAKC,MAAL,C","file":"PiYG.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"e9a3c9f7f7f7a1d76a\",\n  \"d01c8bf1b6dab8e1864dac26\",\n  \"d01c8bf1b6daf7f7f7b8e1864dac26\",\n  \"c51b7de9a3c9fde0efe6f5d0a1d76a4d9221\",\n  \"c51b7de9a3c9fde0eff7f7f7e6f5d0a1d76a4d9221\",\n  \"c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221\",\n  \"c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221\",\n  \"8e0152c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221276419\",\n  \"8e0152c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221276419\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/diverging/PuOr.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("998ec3f7f7f7f1a340", "5e3c99b2abd2fdb863e66101", "5e3c99b2abd2f7f7f7fdb863e66101", "542788998ec3d8daebfee0b6f1a340b35806", "542788998ec3d8daebf7f7f7fee0b6f1a340b35806", "5427888073acb2abd2d8daebfee0b6fdb863e08214b35806", "5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b35806", "2d004b5427888073acb2abd2d8daebfee0b6fdb863e08214b358067f3b08", "2d004b5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b358067f3b08").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=PuOr.js.map

dist/libs/d3-scale-chromatic/diverging/PuOr.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/diverging/PuOr.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlB,8DARkB,EASlB,oEATkB,EAUlBC,GAVkB,CAUdL,MAVc,C;;;;yBAYLC,KAAKC,MAAL,C","file":"PuOr.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"998ec3f7f7f7f1a340\",\n  \"5e3c99b2abd2fdb863e66101\",\n  \"5e3c99b2abd2f7f7f7fdb863e66101\",\n  \"542788998ec3d8daebfee0b6f1a340b35806\",\n  \"542788998ec3d8daebf7f7f7fee0b6f1a340b35806\",\n  \"5427888073acb2abd2d8daebfee0b6fdb863e08214b35806\",\n  \"5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b35806\",\n  \"2d004b5427888073acb2abd2d8daebfee0b6fdb863e08214b358067f3b08\",\n  \"2d004b5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b358067f3b08\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/diverging/RdBu.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("ef8a62f7f7f767a9cf", "ca0020f4a58292c5de0571b0", "ca0020f4a582f7f7f792c5de0571b0", "b2182bef8a62fddbc7d1e5f067a9cf2166ac", "b2182bef8a62fddbc7f7f7f7d1e5f067a9cf2166ac", "b2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac", "b2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac", "67001fb2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac053061", "67001fb2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac053061").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=RdBu.js.map

dist/libs/d3-scale-chromatic/diverging/RdBu.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/diverging/RdBu.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlB,8DARkB,EASlB,oEATkB,EAUlBC,GAVkB,CAUdL,MAVc,C;;;;yBAYLC,KAAKC,MAAL,C","file":"RdBu.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"ef8a62f7f7f767a9cf\",\n  \"ca0020f4a58292c5de0571b0\",\n  \"ca0020f4a582f7f7f792c5de0571b0\",\n  \"b2182bef8a62fddbc7d1e5f067a9cf2166ac\",\n  \"b2182bef8a62fddbc7f7f7f7d1e5f067a9cf2166ac\",\n  \"b2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac\",\n  \"b2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac\",\n  \"67001fb2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac053061\",\n  \"67001fb2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac053061\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/diverging/RdGy.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("ef8a62ffffff999999", "ca0020f4a582bababa404040", "ca0020f4a582ffffffbababa404040", "b2182bef8a62fddbc7e0e0e09999994d4d4d", "b2182bef8a62fddbc7ffffffe0e0e09999994d4d4d", "b2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d", "b2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d", "67001fb2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d1a1a1a", "67001fb2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d1a1a1a").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=RdGy.js.map

dist/libs/d3-scale-chromatic/diverging/RdGy.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/diverging/RdGy.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlB,8DARkB,EASlB,oEATkB,EAUlBC,GAVkB,CAUdL,MAVc,C;;;;yBAYLC,KAAKC,MAAL,C","file":"RdGy.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"ef8a62ffffff999999\",\n  \"ca0020f4a582bababa404040\",\n  \"ca0020f4a582ffffffbababa404040\",\n  \"b2182bef8a62fddbc7e0e0e09999994d4d4d\",\n  \"b2182bef8a62fddbc7ffffffe0e0e09999994d4d4d\",\n  \"b2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d\",\n  \"b2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d\",\n  \"67001fb2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d1a1a1a\",\n  \"67001fb2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d1a1a1a\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/diverging/RdYlBu.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("fc8d59ffffbf91bfdb", "d7191cfdae61abd9e92c7bb6", "d7191cfdae61ffffbfabd9e92c7bb6", "d73027fc8d59fee090e0f3f891bfdb4575b4", "d73027fc8d59fee090ffffbfe0f3f891bfdb4575b4", "d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4", "d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4", "a50026d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4313695", "a50026d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4313695").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=RdYlBu.js.map

dist/libs/d3-scale-chromatic/diverging/RdYlBu.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/diverging/RdYlBu.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlB,8DARkB,EASlB,oEATkB,EAUlBC,GAVkB,CAUdL,MAVc,C;;;;yBAYLC,KAAKC,MAAL,C","file":"RdYlBu.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"fc8d59ffffbf91bfdb\",\n  \"d7191cfdae61abd9e92c7bb6\",\n  \"d7191cfdae61ffffbfabd9e92c7bb6\",\n  \"d73027fc8d59fee090e0f3f891bfdb4575b4\",\n  \"d73027fc8d59fee090ffffbfe0f3f891bfdb4575b4\",\n  \"d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4\",\n  \"d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4\",\n  \"a50026d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4313695\",\n  \"a50026d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4313695\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/diverging/RdYlGn.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("fc8d59ffffbf91cf60", "d7191cfdae61a6d96a1a9641", "d7191cfdae61ffffbfa6d96a1a9641", "d73027fc8d59fee08bd9ef8b91cf601a9850", "d73027fc8d59fee08bffffbfd9ef8b91cf601a9850", "d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850", "d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850", "a50026d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850006837", "a50026d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850006837").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=RdYlGn.js.map

dist/libs/d3-scale-chromatic/diverging/RdYlGn.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/diverging/RdYlGn.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlB,8DARkB,EASlB,oEATkB,EAUlBC,GAVkB,CAUdL,MAVc,C;;;;yBAYLC,KAAKC,MAAL,C","file":"RdYlGn.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"fc8d59ffffbf91cf60\",\n  \"d7191cfdae61a6d96a1a9641\",\n  \"d7191cfdae61ffffbfa6d96a1a9641\",\n  \"d73027fc8d59fee08bd9ef8b91cf601a9850\",\n  \"d73027fc8d59fee08bffffbfd9ef8b91cf601a9850\",\n  \"d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850\",\n  \"d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850\",\n  \"a50026d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850006837\",\n  \"a50026d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850006837\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/diverging/Spectral.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("fc8d59ffffbf99d594", "d7191cfdae61abdda42b83ba", "d7191cfdae61ffffbfabdda42b83ba", "d53e4ffc8d59fee08be6f59899d5943288bd", "d53e4ffc8d59fee08bffffbfe6f59899d5943288bd", "d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd", "d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd", "9e0142d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd5e4fa2", "9e0142d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd5e4fa2").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=Spectral.js.map

dist/libs/d3-scale-chromatic/diverging/Spectral.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/diverging/Spectral.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlB,8DARkB,EASlB,oEATkB,EAUlBC,GAVkB,CAUdL,MAVc,C;;;;yBAYLC,KAAKC,MAAL,C","file":"Spectral.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"fc8d59ffffbf99d594\",\n  \"d7191cfdae61abdda42b83ba\",\n  \"d7191cfdae61ffffbfabdda42b83ba\",\n  \"d53e4ffc8d59fee08be6f59899d5943288bd\",\n  \"d53e4ffc8d59fee08bffffbfe6f59899d5943288bd\",\n  \"d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd\",\n  \"d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd\",\n  \"9e0142d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd5e4fa2\",\n  \"9e0142d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd5e4fa2\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/index.js

@@ -0,0 +1,219 @@
+"use strict";
+
+System.register(["./categorical/Accent", "./categorical/Dark2", "./categorical/Paired", "./categorical/Pastel1", "./categorical/Pastel2", "./categorical/Set1", "./categorical/Set2", "./categorical/Set3", "./diverging/BrBG", "./diverging/PRGn", "./diverging/PiYG", "./diverging/PuOr", "./diverging/RdBu", "./diverging/RdGy", "./diverging/RdYlBu", "./diverging/RdYlGn", "./diverging/GnYlRd", "./diverging/Spectral", "./sequential-multi/BuGn", "./sequential-multi/BuPu", "./sequential-multi/GnBu", "./sequential-multi/OrRd", "./sequential-multi/PuBuGn", "./sequential-multi/PuBu", "./sequential-multi/PuRd", "./sequential-multi/RdPu", "./sequential-multi/YlGnBu", "./sequential-multi/YlGn", "./sequential-multi/YlOrBr", "./sequential-multi/YlOrRd", "./sequential-single/Blues", "./sequential-single/Greens", "./sequential-single/Greys", "./sequential-single/Purples", "./sequential-single/Reds", "./sequential-single/Oranges"], function (_export, _context) {
+  "use strict";
+
+  return {
+    setters: [function (_categoricalAccent) {
+      var _exportObj = {};
+      _exportObj.schemeAccent = _categoricalAccent.default;
+
+      _export(_exportObj);
+    }, function (_categoricalDark) {
+      var _exportObj2 = {};
+      _exportObj2.schemeDark2 = _categoricalDark.default;
+
+      _export(_exportObj2);
+    }, function (_categoricalPaired) {
+      var _exportObj3 = {};
+      _exportObj3.schemePaired = _categoricalPaired.default;
+
+      _export(_exportObj3);
+    }, function (_categoricalPastel) {
+      var _exportObj4 = {};
+      _exportObj4.schemePastel1 = _categoricalPastel.default;
+
+      _export(_exportObj4);
+    }, function (_categoricalPastel2) {
+      var _exportObj5 = {};
+      _exportObj5.schemePastel2 = _categoricalPastel2.default;
+
+      _export(_exportObj5);
+    }, function (_categoricalSet) {
+      var _exportObj6 = {};
+      _exportObj6.schemeSet1 = _categoricalSet.default;
+
+      _export(_exportObj6);
+    }, function (_categoricalSet2) {
+      var _exportObj7 = {};
+      _exportObj7.schemeSet2 = _categoricalSet2.default;
+
+      _export(_exportObj7);
+    }, function (_categoricalSet3) {
+      var _exportObj8 = {};
+      _exportObj8.schemeSet3 = _categoricalSet3.default;
+
+      _export(_exportObj8);
+    }, function (_divergingBrBG) {
+      var _exportObj9 = {};
+      _exportObj9.interpolateBrBG = _divergingBrBG.default;
+      _exportObj9.schemeBrBG = _divergingBrBG.scheme;
+
+      _export(_exportObj9);
+    }, function (_divergingPRGn) {
+      var _exportObj10 = {};
+      _exportObj10.interpolatePRGn = _divergingPRGn.default;
+      _exportObj10.schemePRGn = _divergingPRGn.scheme;
+
+      _export(_exportObj10);
+    }, function (_divergingPiYG) {
+      var _exportObj11 = {};
+      _exportObj11.interpolatePiYG = _divergingPiYG.default;
+      _exportObj11.schemePiYG = _divergingPiYG.scheme;
+
+      _export(_exportObj11);
+    }, function (_divergingPuOr) {
+      var _exportObj12 = {};
+      _exportObj12.interpolatePuOr = _divergingPuOr.default;
+      _exportObj12.schemePuOr = _divergingPuOr.scheme;
+
+      _export(_exportObj12);
+    }, function (_divergingRdBu) {
+      var _exportObj13 = {};
+      _exportObj13.interpolateRdBu = _divergingRdBu.default;
+      _exportObj13.schemeRdBu = _divergingRdBu.scheme;
+
+      _export(_exportObj13);
+    }, function (_divergingRdGy) {
+      var _exportObj14 = {};
+      _exportObj14.interpolateRdGy = _divergingRdGy.default;
+      _exportObj14.schemeRdGy = _divergingRdGy.scheme;
+
+      _export(_exportObj14);
+    }, function (_divergingRdYlBu) {
+      var _exportObj15 = {};
+      _exportObj15.interpolateRdYlBu = _divergingRdYlBu.default;
+      _exportObj15.schemeRdYlBu = _divergingRdYlBu.scheme;
+
+      _export(_exportObj15);
+    }, function (_divergingRdYlGn) {
+      var _exportObj16 = {};
+      _exportObj16.interpolateRdYlGn = _divergingRdYlGn.default;
+      _exportObj16.schemeRdYlGn = _divergingRdYlGn.scheme;
+
+      _export(_exportObj16);
+    }, function (_divergingGnYlRd) {
+      var _exportObj17 = {};
+      _exportObj17.interpolateGnYlRd = _divergingGnYlRd.default;
+      _exportObj17.schemeGnYlRd = _divergingGnYlRd.scheme;
+
+      _export(_exportObj17);
+    }, function (_divergingSpectral) {
+      var _exportObj18 = {};
+      _exportObj18.interpolateSpectral = _divergingSpectral.default;
+      _exportObj18.schemeSpectral = _divergingSpectral.scheme;
+
+      _export(_exportObj18);
+    }, function (_sequentialMultiBuGn) {
+      var _exportObj19 = {};
+      _exportObj19.interpolateBuGn = _sequentialMultiBuGn.default;
+      _exportObj19.schemeBuGn = _sequentialMultiBuGn.scheme;
+
+      _export(_exportObj19);
+    }, function (_sequentialMultiBuPu) {
+      var _exportObj20 = {};
+      _exportObj20.interpolateBuPu = _sequentialMultiBuPu.default;
+      _exportObj20.schemeBuPu = _sequentialMultiBuPu.scheme;
+
+      _export(_exportObj20);
+    }, function (_sequentialMultiGnBu) {
+      var _exportObj21 = {};
+      _exportObj21.interpolateGnBu = _sequentialMultiGnBu.default;
+      _exportObj21.schemeGnBu = _sequentialMultiGnBu.scheme;
+
+      _export(_exportObj21);
+    }, function (_sequentialMultiOrRd) {
+      var _exportObj22 = {};
+      _exportObj22.interpolateOrRd = _sequentialMultiOrRd.default;
+      _exportObj22.schemeOrRd = _sequentialMultiOrRd.scheme;
+
+      _export(_exportObj22);
+    }, function (_sequentialMultiPuBuGn) {
+      var _exportObj23 = {};
+      _exportObj23.interpolatePuBuGn = _sequentialMultiPuBuGn.default;
+      _exportObj23.schemePuBuGn = _sequentialMultiPuBuGn.scheme;
+
+      _export(_exportObj23);
+    }, function (_sequentialMultiPuBu) {
+      var _exportObj24 = {};
+      _exportObj24.interpolatePuBu = _sequentialMultiPuBu.default;
+      _exportObj24.schemePuBu = _sequentialMultiPuBu.scheme;
+
+      _export(_exportObj24);
+    }, function (_sequentialMultiPuRd) {
+      var _exportObj25 = {};
+      _exportObj25.interpolatePuRd = _sequentialMultiPuRd.default;
+      _exportObj25.schemePuRd = _sequentialMultiPuRd.scheme;
+
+      _export(_exportObj25);
+    }, function (_sequentialMultiRdPu) {
+      var _exportObj26 = {};
+      _exportObj26.interpolateRdPu = _sequentialMultiRdPu.default;
+      _exportObj26.schemeRdPu = _sequentialMultiRdPu.scheme;
+
+      _export(_exportObj26);
+    }, function (_sequentialMultiYlGnBu) {
+      var _exportObj27 = {};
+      _exportObj27.interpolateYlGnBu = _sequentialMultiYlGnBu.default;
+      _exportObj27.schemeYlGnBu = _sequentialMultiYlGnBu.scheme;
+
+      _export(_exportObj27);
+    }, function (_sequentialMultiYlGn) {
+      var _exportObj28 = {};
+      _exportObj28.interpolateYlGn = _sequentialMultiYlGn.default;
+      _exportObj28.schemeYlGn = _sequentialMultiYlGn.scheme;
+
+      _export(_exportObj28);
+    }, function (_sequentialMultiYlOrBr) {
+      var _exportObj29 = {};
+      _exportObj29.interpolateYlOrBr = _sequentialMultiYlOrBr.default;
+      _exportObj29.schemeYlOrBr = _sequentialMultiYlOrBr.scheme;
+
+      _export(_exportObj29);
+    }, function (_sequentialMultiYlOrRd) {
+      var _exportObj30 = {};
+      _exportObj30.interpolateYlOrRd = _sequentialMultiYlOrRd.default;
+      _exportObj30.schemeYlOrRd = _sequentialMultiYlOrRd.scheme;
+
+      _export(_exportObj30);
+    }, function (_sequentialSingleBlues) {
+      var _exportObj31 = {};
+      _exportObj31.interpolateBlues = _sequentialSingleBlues.default;
+      _exportObj31.schemeBlues = _sequentialSingleBlues.scheme;
+
+      _export(_exportObj31);
+    }, function (_sequentialSingleGreens) {
+      var _exportObj32 = {};
+      _exportObj32.interpolateGreens = _sequentialSingleGreens.default;
+      _exportObj32.schemeGreens = _sequentialSingleGreens.scheme;
+
+      _export(_exportObj32);
+    }, function (_sequentialSingleGreys) {
+      var _exportObj33 = {};
+      _exportObj33.interpolateGreys = _sequentialSingleGreys.default;
+      _exportObj33.schemeGreys = _sequentialSingleGreys.scheme;
+
+      _export(_exportObj33);
+    }, function (_sequentialSinglePurples) {
+      var _exportObj34 = {};
+      _exportObj34.interpolatePurples = _sequentialSinglePurples.default;
+      _exportObj34.schemePurples = _sequentialSinglePurples.scheme;
+
+      _export(_exportObj34);
+    }, function (_sequentialSingleReds) {
+      var _exportObj35 = {};
+      _exportObj35.interpolateReds = _sequentialSingleReds.default;
+      _exportObj35.schemeReds = _sequentialSingleReds.scheme;
+
+      _export(_exportObj35);
+    }, function (_sequentialSingleOranges) {
+      var _exportObj36 = {};
+      _exportObj36.interpolateOranges = _sequentialSingleOranges.default;
+      _exportObj36.schemeOranges = _sequentialSingleOranges.scheme;
+
+      _export(_exportObj36);
+    }],
+    execute: function () {}
+  };
+});
+//# sourceMappingURL=index.js.map

dist/libs/d3-scale-chromatic/ramp.js

@@ -0,0 +1,19 @@
+'use strict';
+
+System.register(['d3'], function (_export, _context) {
+  "use strict";
+
+  var d3;
+
+  _export('default', function (scheme) {
+    return d3.interpolateRgbBasis(scheme[scheme.length - 1]);
+  });
+
+  return {
+    setters: [function (_d) {
+      d3 = _d.default;
+    }],
+    execute: function () {}
+  };
+});
+//# sourceMappingURL=ramp.js.map

dist/libs/d3-scale-chromatic/ramp.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/libs/d3-scale-chromatic/ramp.js"],"names":["scheme","d3","interpolateRgbBasis","length"],"mappings":";;;;;;;qBAEe,UAASA,MAAT,EAAiB;AAC9B,WAAOC,GAAGC,mBAAH,CAAuBF,OAAOA,OAAOG,MAAP,GAAgB,CAAvB,CAAvB,CAAP;AACD,G;;;;AAJMF,Q","file":"ramp.js","sourcesContent":["import d3 from 'd3';\n\nexport default function(scheme) {\n  return d3.interpolateRgbBasis(scheme[scheme.length - 1]);\n}\n"]}

dist/libs/d3-scale-chromatic/sequential-multi/BuGn.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("e5f5f999d8c92ca25f", "edf8fbb2e2e266c2a4238b45", "edf8fbb2e2e266c2a42ca25f006d2c", "edf8fbccece699d8c966c2a42ca25f006d2c", "edf8fbccece699d8c966c2a441ae76238b45005824", "f7fcfde5f5f9ccece699d8c966c2a441ae76238b45005824", "f7fcfde5f5f9ccece699d8c966c2a441ae76238b45006d2c00441b").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=BuGn.js.map

dist/libs/d3-scale-chromatic/sequential-multi/BuGn.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/sequential-multi/BuGn.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlBC,GARkB,CAQdL,MARc,C;;;;yBAULC,KAAKC,MAAL,C","file":"BuGn.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"e5f5f999d8c92ca25f\",\n  \"edf8fbb2e2e266c2a4238b45\",\n  \"edf8fbb2e2e266c2a42ca25f006d2c\",\n  \"edf8fbccece699d8c966c2a42ca25f006d2c\",\n  \"edf8fbccece699d8c966c2a441ae76238b45005824\",\n  \"f7fcfde5f5f9ccece699d8c966c2a441ae76238b45005824\",\n  \"f7fcfde5f5f9ccece699d8c966c2a441ae76238b45006d2c00441b\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/sequential-multi/BuPu.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("e0ecf49ebcda8856a7", "edf8fbb3cde38c96c688419d", "edf8fbb3cde38c96c68856a7810f7c", "edf8fbbfd3e69ebcda8c96c68856a7810f7c", "edf8fbbfd3e69ebcda8c96c68c6bb188419d6e016b", "f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d6e016b", "f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d810f7c4d004b").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=BuPu.js.map

dist/libs/d3-scale-chromatic/sequential-multi/BuPu.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/sequential-multi/BuPu.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlBC,GARkB,CAQdL,MARc,C;;;;yBAULC,KAAKC,MAAL,C","file":"BuPu.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"e0ecf49ebcda8856a7\",\n  \"edf8fbb3cde38c96c688419d\",\n  \"edf8fbb3cde38c96c68856a7810f7c\",\n  \"edf8fbbfd3e69ebcda8c96c68856a7810f7c\",\n  \"edf8fbbfd3e69ebcda8c96c68c6bb188419d6e016b\",\n  \"f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d6e016b\",\n  \"f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d810f7c4d004b\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/sequential-multi/GnBu.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("e0f3dba8ddb543a2ca", "f0f9e8bae4bc7bccc42b8cbe", "f0f9e8bae4bc7bccc443a2ca0868ac", "f0f9e8ccebc5a8ddb57bccc443a2ca0868ac", "f0f9e8ccebc5a8ddb57bccc44eb3d32b8cbe08589e", "f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe08589e", "f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe0868ac084081").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=GnBu.js.map

dist/libs/d3-scale-chromatic/sequential-multi/GnBu.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/sequential-multi/GnBu.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlBC,GARkB,CAQdL,MARc,C;;;;yBAULC,KAAKC,MAAL,C","file":"GnBu.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"e0f3dba8ddb543a2ca\",\n  \"f0f9e8bae4bc7bccc42b8cbe\",\n  \"f0f9e8bae4bc7bccc443a2ca0868ac\",\n  \"f0f9e8ccebc5a8ddb57bccc443a2ca0868ac\",\n  \"f0f9e8ccebc5a8ddb57bccc44eb3d32b8cbe08589e\",\n  \"f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe08589e\",\n  \"f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe0868ac084081\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/sequential-multi/OrRd.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("fee8c8fdbb84e34a33", "fef0d9fdcc8afc8d59d7301f", "fef0d9fdcc8afc8d59e34a33b30000", "fef0d9fdd49efdbb84fc8d59e34a33b30000", "fef0d9fdd49efdbb84fc8d59ef6548d7301f990000", "fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301f990000", "fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301fb300007f0000").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=OrRd.js.map

dist/libs/d3-scale-chromatic/sequential-multi/OrRd.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/sequential-multi/OrRd.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlBC,GARkB,CAQdL,MARc,C;;;;yBAULC,KAAKC,MAAL,C","file":"OrRd.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"fee8c8fdbb84e34a33\",\n  \"fef0d9fdcc8afc8d59d7301f\",\n  \"fef0d9fdcc8afc8d59e34a33b30000\",\n  \"fef0d9fdd49efdbb84fc8d59e34a33b30000\",\n  \"fef0d9fdd49efdbb84fc8d59ef6548d7301f990000\",\n  \"fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301f990000\",\n  \"fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301fb300007f0000\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/sequential-multi/PuBu.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("ece7f2a6bddb2b8cbe", "f1eef6bdc9e174a9cf0570b0", "f1eef6bdc9e174a9cf2b8cbe045a8d", "f1eef6d0d1e6a6bddb74a9cf2b8cbe045a8d", "f1eef6d0d1e6a6bddb74a9cf3690c00570b0034e7b", "fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0034e7b", "fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0045a8d023858").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=PuBu.js.map

dist/libs/d3-scale-chromatic/sequential-multi/PuBu.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/sequential-multi/PuBu.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlBC,GARkB,CAQdL,MARc,C;;;;yBAULC,KAAKC,MAAL,C","file":"PuBu.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"ece7f2a6bddb2b8cbe\",\n  \"f1eef6bdc9e174a9cf0570b0\",\n  \"f1eef6bdc9e174a9cf2b8cbe045a8d\",\n  \"f1eef6d0d1e6a6bddb74a9cf2b8cbe045a8d\",\n  \"f1eef6d0d1e6a6bddb74a9cf3690c00570b0034e7b\",\n  \"fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0034e7b\",\n  \"fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0045a8d023858\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/sequential-multi/PuBuGn.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("ece2f0a6bddb1c9099", "f6eff7bdc9e167a9cf02818a", "f6eff7bdc9e167a9cf1c9099016c59", "f6eff7d0d1e6a6bddb67a9cf1c9099016c59", "f6eff7d0d1e6a6bddb67a9cf3690c002818a016450", "fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016450", "fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016c59014636").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=PuBuGn.js.map

dist/libs/d3-scale-chromatic/sequential-multi/PuBuGn.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/sequential-multi/PuBuGn.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlBC,GARkB,CAQdL,MARc,C;;;;yBAULC,KAAKC,MAAL,C","file":"PuBuGn.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"ece2f0a6bddb1c9099\",\n  \"f6eff7bdc9e167a9cf02818a\",\n  \"f6eff7bdc9e167a9cf1c9099016c59\",\n  \"f6eff7d0d1e6a6bddb67a9cf1c9099016c59\",\n  \"f6eff7d0d1e6a6bddb67a9cf3690c002818a016450\",\n  \"fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016450\",\n  \"fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016c59014636\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/sequential-multi/PuRd.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("e7e1efc994c7dd1c77", "f1eef6d7b5d8df65b0ce1256", "f1eef6d7b5d8df65b0dd1c77980043", "f1eef6d4b9dac994c7df65b0dd1c77980043", "f1eef6d4b9dac994c7df65b0e7298ace125691003f", "f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125691003f", "f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125698004367001f").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=PuRd.js.map

dist/libs/d3-scale-chromatic/sequential-multi/PuRd.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/sequential-multi/PuRd.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlBC,GARkB,CAQdL,MARc,C;;;;yBAULC,KAAKC,MAAL,C","file":"PuRd.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"e7e1efc994c7dd1c77\",\n  \"f1eef6d7b5d8df65b0ce1256\",\n  \"f1eef6d7b5d8df65b0dd1c77980043\",\n  \"f1eef6d4b9dac994c7df65b0dd1c77980043\",\n  \"f1eef6d4b9dac994c7df65b0e7298ace125691003f\",\n  \"f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125691003f\",\n  \"f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125698004367001f\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/sequential-multi/RdPu.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("fde0ddfa9fb5c51b8a", "feebe2fbb4b9f768a1ae017e", "feebe2fbb4b9f768a1c51b8a7a0177", "feebe2fcc5c0fa9fb5f768a1c51b8a7a0177", "feebe2fcc5c0fa9fb5f768a1dd3497ae017e7a0177", "fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a0177", "fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a017749006a").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=RdPu.js.map

dist/libs/d3-scale-chromatic/sequential-multi/RdPu.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/sequential-multi/RdPu.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlBC,GARkB,CAQdL,MARc,C;;;;yBAULC,KAAKC,MAAL,C","file":"RdPu.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"fde0ddfa9fb5c51b8a\",\n  \"feebe2fbb4b9f768a1ae017e\",\n  \"feebe2fbb4b9f768a1c51b8a7a0177\",\n  \"feebe2fcc5c0fa9fb5f768a1c51b8a7a0177\",\n  \"feebe2fcc5c0fa9fb5f768a1dd3497ae017e7a0177\",\n  \"fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a0177\",\n  \"fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a017749006a\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/sequential-multi/YlGn.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("f7fcb9addd8e31a354", "ffffccc2e69978c679238443", "ffffccc2e69978c67931a354006837", "ffffccd9f0a3addd8e78c67931a354006837", "ffffccd9f0a3addd8e78c67941ab5d238443005a32", "ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443005a32", "ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443006837004529").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=YlGn.js.map

dist/libs/d3-scale-chromatic/sequential-multi/YlGn.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/sequential-multi/YlGn.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlBC,GARkB,CAQdL,MARc,C;;;;yBAULC,KAAKC,MAAL,C","file":"YlGn.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"f7fcb9addd8e31a354\",\n  \"ffffccc2e69978c679238443\",\n  \"ffffccc2e69978c67931a354006837\",\n  \"ffffccd9f0a3addd8e78c67931a354006837\",\n  \"ffffccd9f0a3addd8e78c67941ab5d238443005a32\",\n  \"ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443005a32\",\n  \"ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443006837004529\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/sequential-multi/YlGnBu.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("edf8b17fcdbb2c7fb8", "ffffcca1dab441b6c4225ea8", "ffffcca1dab441b6c42c7fb8253494", "ffffccc7e9b47fcdbb41b6c42c7fb8253494", "ffffccc7e9b47fcdbb41b6c41d91c0225ea80c2c84", "ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea80c2c84", "ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea8253494081d58").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=YlGnBu.js.map

dist/libs/d3-scale-chromatic/sequential-multi/YlGnBu.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/sequential-multi/YlGnBu.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlBC,GARkB,CAQdL,MARc,C;;;;yBAULC,KAAKC,MAAL,C","file":"YlGnBu.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"edf8b17fcdbb2c7fb8\",\n  \"ffffcca1dab441b6c4225ea8\",\n  \"ffffcca1dab441b6c42c7fb8253494\",\n  \"ffffccc7e9b47fcdbb41b6c42c7fb8253494\",\n  \"ffffccc7e9b47fcdbb41b6c41d91c0225ea80c2c84\",\n  \"ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea80c2c84\",\n  \"ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea8253494081d58\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/sequential-multi/YlOrBr.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("fff7bcfec44fd95f0e", "ffffd4fed98efe9929cc4c02", "ffffd4fed98efe9929d95f0e993404", "ffffd4fee391fec44ffe9929d95f0e993404", "ffffd4fee391fec44ffe9929ec7014cc4c028c2d04", "ffffe5fff7bcfee391fec44ffe9929ec7014cc4c028c2d04", "ffffe5fff7bcfee391fec44ffe9929ec7014cc4c02993404662506").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=YlOrBr.js.map

dist/libs/d3-scale-chromatic/sequential-multi/YlOrBr.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/sequential-multi/YlOrBr.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlBC,GARkB,CAQdL,MARc,C;;;;yBAULC,KAAKC,MAAL,C","file":"YlOrBr.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"fff7bcfec44fd95f0e\",\n  \"ffffd4fed98efe9929cc4c02\",\n  \"ffffd4fed98efe9929d95f0e993404\",\n  \"ffffd4fee391fec44ffe9929d95f0e993404\",\n  \"ffffd4fee391fec44ffe9929ec7014cc4c028c2d04\",\n  \"ffffe5fff7bcfee391fec44ffe9929ec7014cc4c028c2d04\",\n  \"ffffe5fff7bcfee391fec44ffe9929ec7014cc4c02993404662506\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/sequential-multi/YlOrRd.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("ffeda0feb24cf03b20", "ffffb2fecc5cfd8d3ce31a1c", "ffffb2fecc5cfd8d3cf03b20bd0026", "ffffb2fed976feb24cfd8d3cf03b20bd0026", "ffffb2fed976feb24cfd8d3cfc4e2ae31a1cb10026", "ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cb10026", "ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cbd0026800026").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=YlOrRd.js.map

dist/libs/d3-scale-chromatic/sequential-multi/YlOrRd.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/sequential-multi/YlOrRd.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlBC,GARkB,CAQdL,MARc,C;;;;yBAULC,KAAKC,MAAL,C","file":"YlOrRd.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"ffeda0feb24cf03b20\",\n  \"ffffb2fecc5cfd8d3ce31a1c\",\n  \"ffffb2fecc5cfd8d3cf03b20bd0026\",\n  \"ffffb2fed976feb24cfd8d3cf03b20bd0026\",\n  \"ffffb2fed976feb24cfd8d3cfc4e2ae31a1cb10026\",\n  \"ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cb10026\",\n  \"ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cbd0026800026\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/sequential-single/Blues.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("deebf79ecae13182bd", "eff3ffbdd7e76baed62171b5", "eff3ffbdd7e76baed63182bd08519c", "eff3ffc6dbef9ecae16baed63182bd08519c", "eff3ffc6dbef9ecae16baed64292c62171b5084594", "f7fbffdeebf7c6dbef9ecae16baed64292c62171b5084594", "f7fbffdeebf7c6dbef9ecae16baed64292c62171b508519c08306b").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=Blues.js.map

dist/libs/d3-scale-chromatic/sequential-single/Blues.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/sequential-single/Blues.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlBC,GARkB,CAQdL,MARc,C;;;;yBAULC,KAAKC,MAAL,C","file":"Blues.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"deebf79ecae13182bd\",\n  \"eff3ffbdd7e76baed62171b5\",\n  \"eff3ffbdd7e76baed63182bd08519c\",\n  \"eff3ffc6dbef9ecae16baed63182bd08519c\",\n  \"eff3ffc6dbef9ecae16baed64292c62171b5084594\",\n  \"f7fbffdeebf7c6dbef9ecae16baed64292c62171b5084594\",\n  \"f7fbffdeebf7c6dbef9ecae16baed64292c62171b508519c08306b\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/sequential-single/Greens.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("e5f5e0a1d99b31a354", "edf8e9bae4b374c476238b45", "edf8e9bae4b374c47631a354006d2c", "edf8e9c7e9c0a1d99b74c47631a354006d2c", "edf8e9c7e9c0a1d99b74c47641ab5d238b45005a32", "f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45005a32", "f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45006d2c00441b").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=Greens.js.map

dist/libs/d3-scale-chromatic/sequential-single/Greens.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/sequential-single/Greens.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlBC,GARkB,CAQdL,MARc,C;;;;yBAULC,KAAKC,MAAL,C","file":"Greens.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"e5f5e0a1d99b31a354\",\n  \"edf8e9bae4b374c476238b45\",\n  \"edf8e9bae4b374c47631a354006d2c\",\n  \"edf8e9c7e9c0a1d99b74c47631a354006d2c\",\n  \"edf8e9c7e9c0a1d99b74c47641ab5d238b45005a32\",\n  \"f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45005a32\",\n  \"f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45006d2c00441b\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/sequential-single/Greys.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("f0f0f0bdbdbd636363", "f7f7f7cccccc969696525252", "f7f7f7cccccc969696636363252525", "f7f7f7d9d9d9bdbdbd969696636363252525", "f7f7f7d9d9d9bdbdbd969696737373525252252525", "fffffff0f0f0d9d9d9bdbdbd969696737373525252252525", "fffffff0f0f0d9d9d9bdbdbd969696737373525252252525000000").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=Greys.js.map

dist/libs/d3-scale-chromatic/sequential-single/Greys.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/sequential-single/Greys.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlBC,GARkB,CAQdL,MARc,C;;;;yBAULC,KAAKC,MAAL,C","file":"Greys.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"f0f0f0bdbdbd636363\",\n  \"f7f7f7cccccc969696525252\",\n  \"f7f7f7cccccc969696636363252525\",\n  \"f7f7f7d9d9d9bdbdbd969696636363252525\",\n  \"f7f7f7d9d9d9bdbdbd969696737373525252252525\",\n  \"fffffff0f0f0d9d9d9bdbdbd969696737373525252252525\",\n  \"fffffff0f0f0d9d9d9bdbdbd969696737373525252252525000000\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/sequential-single/Oranges.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("fee6cefdae6be6550d", "feeddefdbe85fd8d3cd94701", "feeddefdbe85fd8d3ce6550da63603", "feeddefdd0a2fdae6bfd8d3ce6550da63603", "feeddefdd0a2fdae6bfd8d3cf16913d948018c2d04", "fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d948018c2d04", "fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d94801a636037f2704").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=Oranges.js.map

dist/libs/d3-scale-chromatic/sequential-single/Oranges.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/sequential-single/Oranges.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlBC,GARkB,CAQdL,MARc,C;;;;yBAULC,KAAKC,MAAL,C","file":"Oranges.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"fee6cefdae6be6550d\",\n  \"feeddefdbe85fd8d3cd94701\",\n  \"feeddefdbe85fd8d3ce6550da63603\",\n  \"feeddefdd0a2fdae6bfd8d3ce6550da63603\",\n  \"feeddefdd0a2fdae6bfd8d3cf16913d948018c2d04\",\n  \"fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d948018c2d04\",\n  \"fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d94801a636037f2704\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/sequential-single/Purples.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("efedf5bcbddc756bb1", "f2f0f7cbc9e29e9ac86a51a3", "f2f0f7cbc9e29e9ac8756bb154278f", "f2f0f7dadaebbcbddc9e9ac8756bb154278f", "f2f0f7dadaebbcbddc9e9ac8807dba6a51a34a1486", "fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a34a1486", "fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a354278f3f007d").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=Purples.js.map

dist/libs/d3-scale-chromatic/sequential-single/Purples.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/sequential-single/Purples.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlBC,GARkB,CAQdL,MARc,C;;;;yBAULC,KAAKC,MAAL,C","file":"Purples.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"efedf5bcbddc756bb1\",\n  \"f2f0f7cbc9e29e9ac86a51a3\",\n  \"f2f0f7cbc9e29e9ac8756bb154278f\",\n  \"f2f0f7dadaebbcbddc9e9ac8756bb154278f\",\n  \"f2f0f7dadaebbcbddc9e9ac8807dba6a51a34a1486\",\n  \"fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a34a1486\",\n  \"fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a354278f3f007d\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/libs/d3-scale-chromatic/sequential-single/Reds.js

@@ -0,0 +1,22 @@
+"use strict";
+
+System.register(["../colors", "../ramp"], function (_export, _context) {
+  "use strict";
+
+  var colors, ramp, scheme;
+  return {
+    setters: [function (_colors) {
+      colors = _colors.default;
+    }, function (_ramp) {
+      ramp = _ramp.default;
+    }],
+    execute: function () {
+      _export("scheme", scheme = new Array(3).concat("fee0d2fc9272de2d26", "fee5d9fcae91fb6a4acb181d", "fee5d9fcae91fb6a4ade2d26a50f15", "fee5d9fcbba1fc9272fb6a4ade2d26a50f15", "fee5d9fcbba1fc9272fb6a4aef3b2ccb181d99000d", "fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181d99000d", "fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181da50f1567000d").map(colors));
+
+      _export("scheme", scheme);
+
+      _export("default", ramp(scheme));
+    }
+  };
+});
+//# sourceMappingURL=Reds.js.map

dist/libs/d3-scale-chromatic/sequential-single/Reds.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/libs/d3-scale-chromatic/sequential-single/Reds.js"],"names":["colors","ramp","scheme","Array","concat","map"],"mappings":";;;;;;;;AAAOA,Y;;AACAC,U;;;wBAEIC,M,GAAS,IAAIC,KAAJ,CAAU,CAAV,EAAaC,MAAb,CAClB,oBADkB,EAElB,0BAFkB,EAGlB,gCAHkB,EAIlB,sCAJkB,EAKlB,4CALkB,EAMlB,kDANkB,EAOlB,wDAPkB,EAQlBC,GARkB,CAQdL,MARc,C;;;;yBAULC,KAAKC,MAAL,C","file":"Reds.js","sourcesContent":["import colors from \"../colors\";\nimport ramp from \"../ramp\";\n\nexport var scheme = new Array(3).concat(\n  \"fee0d2fc9272de2d26\",\n  \"fee5d9fcae91fb6a4acb181d\",\n  \"fee5d9fcae91fb6a4ade2d26a50f15\",\n  \"fee5d9fcbba1fc9272fb6a4ade2d26a50f15\",\n  \"fee5d9fcbba1fc9272fb6a4aef3b2ccb181d99000d\",\n  \"fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181d99000d\",\n  \"fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181da50f1567000d\"\n).map(colors);\n\nexport default ramp(scheme);\n"]}

dist/module.html

@@ -0,0 +1,15 @@
+<div class="status-heatmap-wrapper">
+	<div class="status-heatmap-canvas-wrapper">
+
+		<div class="datapoints-warning">
+			<span class="small" ng-if="ctrl.multipleValues" bs-tooltip="'{{ctrl.dataWarnings.multipleValues.tip}}'">{{ctrl.dataWarnings.multipleValues.title}}</span>
+			<span class="small" ng-if="ctrl.noColorDefined" bs-tooltip="'{{ctrl.dataWarnings.noColorDefined.tip}}'">{{ctrl.dataWarnings.noColorDefined.title}}</span>
+		</div>
+
+		<div class="status-heatmap-panel" ng-dblclick="ctrl.zoomOut()"></div>
+	</div>
+	<div class="status-heatmap-legend-wrapper" ng-if="ctrl.panel.legend.show">
+		<status-heatmap-legend></status-heatmap-legend>
+	</div>
+</div>
+<div class="clearfix"></div>

dist/module.js

@@ -0,0 +1,16 @@
+'use strict';
+
+System.register(['./color_legend', './status_heatmap_ctrl'], function (_export, _context) {
+  "use strict";
+
+  var StatusHeatmapCtrl;
+  return {
+    setters: [function (_color_legend) {}, function (_status_heatmap_ctrl) {
+      StatusHeatmapCtrl = _status_heatmap_ctrl.StatusHeatmapCtrl;
+    }],
+    execute: function () {
+      _export('PanelCtrl', StatusHeatmapCtrl);
+    }
+  };
+});
+//# sourceMappingURL=module.js.map

dist/options_editor.js

@@ -0,0 +1,77 @@
+'use strict';
+
+System.register(['app/core/utils/kbn'], function (_export, _context) {
+  "use strict";
+
+  var kbn, _createClass, StatusHeatmapOptionsEditorCtrl;
+
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+
+  function statusHeatmapOptionsEditor() {
+    'use strict';
+
+    return {
+      restrict: 'E',
+      scope: true,
+      templateUrl: 'public/plugins/status-heatmap-panel/partials/options_editor.html',
+      controller: StatusHeatmapOptionsEditorCtrl
+    };
+  }
+
+  _export('statusHeatmapOptionsEditor', statusHeatmapOptionsEditor);
+
+  return {
+    setters: [function (_appCoreUtilsKbn) {
+      kbn = _appCoreUtilsKbn.default;
+    }],
+    execute: function () {
+      _createClass = function () {
+        function defineProperties(target, props) {
+          for (var i = 0; i < props.length; i++) {
+            var descriptor = props[i];
+            descriptor.enumerable = descriptor.enumerable || false;
+            descriptor.configurable = true;
+            if ("value" in descriptor) descriptor.writable = true;
+            Object.defineProperty(target, descriptor.key, descriptor);
+          }
+        }
+
+        return function (Constructor, protoProps, staticProps) {
+          if (protoProps) defineProperties(Constructor.prototype, protoProps);
+          if (staticProps) defineProperties(Constructor, staticProps);
+          return Constructor;
+        };
+      }();
+
+      _export('StatusHeatmapOptionsEditorCtrl', StatusHeatmapOptionsEditorCtrl = function () {
+        function StatusHeatmapOptionsEditorCtrl($scope) {
+          _classCallCheck(this, StatusHeatmapOptionsEditorCtrl);
+
+          $scope.editor = this;
+          this.panelCtrl = $scope.ctrl;
+          this.panel = this.panelCtrl.panel;
+          this.unitFormats = kbn.getUnitFormats();
+
+          this.panelCtrl.render();
+        }
+
+        _createClass(StatusHeatmapOptionsEditorCtrl, [{
+          key: 'setUnitFormat',
+          value: function setUnitFormat(subItem) {
+            this.panel.data.unitFormat = subItem.value;
+            this.panelCtrl.render();
+          }
+        }]);
+
+        return StatusHeatmapOptionsEditorCtrl;
+      }());
+
+      _export('StatusHeatmapOptionsEditorCtrl', StatusHeatmapOptionsEditorCtrl);
+    }
+  };
+});
+//# sourceMappingURL=options_editor.js.map

dist/plugin.json

@@ -0,0 +1,35 @@
+{
+  "type": "panel",
+  "name": "Statusmap",
+  "id": "flant-statusmap-panel",
+
+  "info": {
+    "description": "Statusmap panel for grafana",
+    "author": {
+      "name": "Flant JSC",
+      "url": "http://flant.com"
+    },
+    "keywords": ["status", "heatmap", "panel"],
+    "logos": {
+      "small": "img/logo.svg",
+      "large": "img/logo.svg"
+    },
+    "links": [
+      {"name": "Github", "url": "https://github.com/flant/grafana-statusmap"},
+      {"name": "MIT Licence", "url": "https://github.com/flant/grafana-statusmap/blob/master/LICENSE"}
+
+    ],
+    "screenshots": [
+      {"name": "Panel", "path": "img/flant-statusmap-panel.png"},
+      {"name": "Color mapping", "path": "img/color-mapping.png"},
+      {"name": "Queries example", "path": "img/queries-example.png"}
+    ],
+    "version": "0.0.1",
+    "updated": "2018-09-17"
+  },
+
+  "dependencies": {
+    "grafanaVersion": "5.1.x",
+    "plugins": [ ]
+  }
+}

dist/rendering.js

@@ -0,0 +1,639 @@
+'use strict';
+
+System.register(['lodash', 'jquery', 'moment', 'app/core/utils/kbn', 'app/core/core', 'app/core/utils/ticks', 'd3', './libs/d3-scale-chromatic/index', './tooltip'], function (_export, _context) {
+  "use strict";
+
+  var _, $, moment, kbn, appEvents, contextSrv, tickStep, getScaledDecimals, getFlotTickSize, d3, d3ScaleChromatic, StatusHeatmapTooltip, MIN_CARD_SIZE, CARD_SPACING, CARD_ROUND, DATA_RANGE_WIDING_FACTOR, DEFAULT_X_TICK_SIZE_PX, DEFAULT_Y_TICK_SIZE_PX, X_AXIS_TICK_PADDING, Y_AXIS_TICK_PADDING, MIN_SELECTION_WIDTH;
+
+  function link(scope, elem, attrs, ctrl) {
+    var data = void 0,
+        cardsData = void 0,
+        timeRange = void 0,
+        panel = void 0,
+        heatmap = void 0;
+
+    // $heatmap is JQuery object, but heatmap is D3
+    var $heatmap = elem.find('.status-heatmap-panel');
+    var tooltip = new StatusHeatmapTooltip($heatmap, scope);
+
+    var width = void 0,
+        height = void 0,
+        yScale = void 0,
+        xScale = void 0,
+        chartWidth = void 0,
+        chartHeight = void 0,
+        chartTop = void 0,
+        chartBottom = void 0,
+        yAxisWidth = void 0,
+        xAxisHeight = void 0,
+        cardSpacing = void 0,
+        cardRound = void 0,
+        cardWidth = void 0,
+        cardHeight = void 0,
+        colorScale = void 0,
+        opacityScale = void 0,
+        mouseUpHandler = void 0,
+        xGridSize = void 0,
+        yGridSize = void 0;
+
+    var yOffset = 0;
+
+    var selection = {
+      active: false,
+      x1: -1,
+      x2: -1
+    };
+
+    var padding = { left: 0, right: 0, top: 0, bottom: 0 },
+        margin = { left: 25, right: 15, top: 10, bottom: 20 },
+        dataRangeWidingFactor = DATA_RANGE_WIDING_FACTOR;
+
+    ctrl.events.on('render', function () {
+      render();
+    });
+
+    function setElementHeight() {
+      try {
+        var height = ctrl.height || panel.height || ctrl.row.height;
+        if (_.isString(height)) {
+          height = parseInt(height.replace('px', ''), 10);
+        }
+
+        height -= panel.legend.show ? 32 : 10; // bottom padding and space for legend. Change margin in .status-heatmap-color-legend !
+
+        $heatmap.css('height', height + 'px');
+
+        return true;
+      } catch (e) {
+        // IE throws errors sometimes
+        return false;
+      }
+    }
+
+    function getYAxisWidth(elem) {
+      var axis_text = elem.selectAll(".axis-y text").nodes();
+      var max_text_width = _.max(_.map(axis_text, function (text) {
+        // Use SVG getBBox method
+        return text.getBBox().width;
+      }));
+
+      return max_text_width;
+    }
+
+    function getXAxisHeight(elem) {
+      var axis_line = elem.select(".axis-x line");
+      if (!axis_line.empty()) {
+        var axis_line_position = parseFloat(elem.select(".axis-x line").attr("y2"));
+        var canvas_width = parseFloat(elem.attr("height"));
+        return canvas_width - axis_line_position;
+      } else {
+        // Default height
+        return 30;
+      }
+    }
+
+    function addXAxis() {
+      // Scale timestamps to cards centers
+      scope.xScale = xScale = d3.scaleTime().domain([timeRange.from, timeRange.to]).range([xGridSize / 2, chartWidth - xGridSize / 2]);
+
+      var ticks = chartWidth / DEFAULT_X_TICK_SIZE_PX;
+      var grafanaTimeFormatter = grafanaTimeFormat(ticks, timeRange.from, timeRange.to);
+      var timeFormat = void 0;
+      var dashboardTimeZone = ctrl.dashboard.getTimezone();
+      if (dashboardTimeZone === 'utc') {
+        timeFormat = d3.utcFormat(grafanaTimeFormatter);
+      } else {
+        timeFormat = d3.timeFormat(grafanaTimeFormatter);
+      }
+
+      var xAxis = d3.axisBottom(xScale).ticks(ticks).tickFormat(timeFormat).tickPadding(X_AXIS_TICK_PADDING).tickSize(chartHeight);
+
+      var posY = chartTop;
+      var posX = yAxisWidth;
+
+      heatmap.append("g").attr("class", "axis axis-x").attr("transform", "translate(" + posX + "," + posY + ")").call(xAxis);
+
+      // Remove horizontal line in the top of axis labels (called domain in d3)
+      heatmap.select(".axis-x").select(".domain").remove();
+    }
+
+    // divide chart height by ticks for cards drawing
+    function getYScale(ticks) {
+      var range = [];
+      var step = chartHeight / ticks.length;
+      range.push(chartHeight);
+      for (var i = 1; i < ticks.length; i++) {
+        range.push(chartHeight - step * i);
+      }
+      return d3.scaleOrdinal().domain(ticks).range(range);
+    }
+
+    // divide chart height by ticks with offset for ticks drawing
+    function getYAxisScale(ticks) {
+      var range = [];
+      var step = chartHeight / ticks.length;
+      range.push(chartHeight - yOffset);
+      for (var i = 1; i < ticks.length; i++) {
+        range.push(chartHeight - step * i - yOffset);
+      }
+      return d3.scaleOrdinal().domain(ticks).range(range);
+    }
+
+    function addYAxis() {
+      var ticks = _.uniq(_.map(data, function (d) {
+        return d.target;
+      }));
+
+      // Set default Y min and max if no data
+      if (_.isEmpty(data)) {
+        ticks = [''];
+      }
+
+      var yAxisScale = getYAxisScale(ticks);
+      scope.yScale = yScale = getYScale(ticks);
+
+      var yAxis = d3.axisLeft(yAxisScale).tickValues(ticks).tickSizeInner(0 - width).tickPadding(Y_AXIS_TICK_PADDING);
+
+      heatmap.append("g").attr("class", "axis axis-y").call(yAxis);
+
+      // Calculate Y axis width first, then move axis into visible area
+      var posY = margin.top;
+      var posX = getYAxisWidth(heatmap) + Y_AXIS_TICK_PADDING;
+      heatmap.select(".axis-y").attr("transform", "translate(" + posX + "," + posY + ")");
+
+      // Remove vertical line in the right of axis labels (called domain in d3)
+      heatmap.select(".axis-y").select(".domain").remove();
+      heatmap.select(".axis-y").selectAll(".tick line").remove();
+    }
+
+    // Wide Y values range and adjust to bucket size
+    function wideYAxisRange(min, max, tickInterval) {
+      var y_widing = (max * (dataRangeWidingFactor - 1) - min * (dataRangeWidingFactor - 1)) / 2;
+      var y_min = void 0,
+          y_max = void 0;
+
+      if (tickInterval === 0) {
+        y_max = max * dataRangeWidingFactor;
+        y_min = min - min * (dataRangeWidingFactor - 1);
+        tickInterval = (y_max - y_min) / 2;
+      } else {
+        y_max = Math.ceil((max + y_widing) / tickInterval) * tickInterval;
+        y_min = Math.floor((min - y_widing) / tickInterval) * tickInterval;
+      }
+
+      // Don't wide axis below 0 if all values are positive
+      if (min >= 0 && y_min < 0) {
+        y_min = 0;
+      }
+
+      return { y_min: y_min, y_max: y_max };
+    }
+
+    function tickValueFormatter(decimals) {
+      var scaledDecimals = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+
+      var format = panel.yAxis.format;
+      return function (value) {
+        return kbn.valueFormats[format](value, decimals, scaledDecimals);
+      };
+    }
+
+    // Create svg element, add axes and
+    // calculate sizes for cards drawing
+    function addHeatmapCanvas() {
+      var heatmap_elem = $heatmap[0];
+
+      width = Math.floor($heatmap.width()) - padding.right;
+      height = Math.floor($heatmap.height()) - padding.bottom;
+
+      if (heatmap) {
+        heatmap.remove();
+      }
+
+      heatmap = d3.select(heatmap_elem).append("svg").attr("width", width).attr("height", height);
+
+      chartHeight = height - margin.top - margin.bottom;
+      chartTop = margin.top;
+      chartBottom = chartTop + chartHeight;
+
+      cardSpacing = panel.cards.cardSpacing !== null ? panel.cards.cardSpacing : CARD_SPACING;
+      cardRound = panel.cards.cardRound !== null ? panel.cards.cardRound : CARD_ROUND;
+
+      // calculate yOffset for YAxis
+      yGridSize = Math.floor(chartHeight / cardsData.yBucketSize);
+      cardHeight = yGridSize ? yGridSize - cardSpacing : 0;
+      yOffset = cardHeight / 2;
+
+      addYAxis();
+
+      yAxisWidth = getYAxisWidth(heatmap) + Y_AXIS_TICK_PADDING;
+      chartWidth = width - yAxisWidth - margin.right;
+
+      // we need to fill chartWidth with xBucketSize cards.
+      xGridSize = chartWidth / (cardsData.xBucketSize + 1);
+      cardWidth = xGridSize - cardSpacing;
+
+      addXAxis();
+      xAxisHeight = getXAxisHeight(heatmap);
+
+      if (!panel.yAxis.show) {
+        heatmap.select(".axis-y").selectAll("line").style("opacity", 0);
+      }
+
+      if (!panel.xAxis.show) {
+        heatmap.select(".axis-x").selectAll("line").style("opacity", 0);
+      }
+    }
+
+    function addHeatmap() {
+      addHeatmapCanvas();
+
+      var maxValue = panel.color.max || cardsData.maxValue;
+      var minValue = panel.color.min || cardsData.minValue;
+
+      if (panel.color.mode !== 'discrete') {
+        colorScale = getColorScale(maxValue, minValue);
+      }
+      setOpacityScale(maxValue);
+
+      var cards = heatmap.selectAll(".status-heatmap-card").data(cardsData.cards);
+      cards.append("title");
+      cards = cards.enter().append("rect").attr("cardId", function (c) {
+        return c.id;
+      }).attr("x", getCardX).attr("width", getCardWidth).attr("y", getCardY).attr("height", getCardHeight).attr("rx", cardRound).attr("ry", cardRound).attr("class", "bordered status-heatmap-card").style("fill", getCardColor).style("stroke", getCardColor).style("stroke-width", 0)
+      //.style("stroke-width", getCardStrokeWidth)
+      //.style("stroke-dasharray", "3,3")
+      .style("opacity", getCardOpacity);
+
+      var $cards = $heatmap.find(".status-heatmap-card");
+      $cards.on("mouseenter", function (event) {
+        tooltip.mouseOverBucket = true;
+        highlightCard(event);
+      }).on("mouseleave", function (event) {
+        tooltip.mouseOverBucket = false;
+        resetCardHighLight(event);
+      });
+
+      ctrl.events.emit('render-complete', {
+        "chartWidth": chartWidth
+      });
+    }
+
+    function highlightCard(event) {
+      var color = d3.select(event.target).style("fill");
+      var highlightColor = d3.color(color).darker(2);
+      var strokeColor = d3.color(color).brighter(4);
+      var current_card = d3.select(event.target);
+      tooltip.originalFillColor = color;
+      current_card.style("fill", highlightColor).style("stroke", strokeColor).style("stroke-width", 1);
+    }
+
+    function resetCardHighLight(event) {
+      d3.select(event.target).style("fill", tooltip.originalFillColor).style("stroke", tooltip.originalFillColor).style("stroke-width", 0);
+    }
+
+    function getColorScale(maxValue) {
+      var minValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+
+      var colorScheme = _.find(ctrl.colorSchemes, { value: panel.color.colorScheme });
+      var colorInterpolator = d3ScaleChromatic[colorScheme.value];
+      var colorScaleInverted = colorScheme.invert === 'always' || colorScheme.invert === 'dark' && !contextSrv.user.lightTheme;
+
+      if (maxValue == minValue) maxValue = minValue + 1;
+
+      var start = colorScaleInverted ? maxValue : minValue;
+      var end = colorScaleInverted ? minValue : maxValue;
+
+      return d3.scaleSequential(colorInterpolator).domain([start, end]);
+    }
+
+    function setOpacityScale(maxValue) {
+      if (panel.color.colorScale === 'linear') {
+        opacityScale = d3.scaleLinear().domain([0, maxValue]).range([0, 1]);
+      } else if (panel.color.colorScale === 'sqrt') {
+        opacityScale = d3.scalePow().exponent(panel.color.exponent).domain([0, maxValue]).range([0, 1]);
+      }
+    }
+
+    function getCardX(d) {
+      var x = void 0;
+      // cx is the center of the card. Card should be placed to the left.
+      var cx = xScale(d.x);
+
+      if (cx - cardWidth / 2 < 0) {
+        x = yAxisWidth + cardSpacing / 2;
+      } else {
+        x = yAxisWidth + cx - cardWidth / 2;
+      }
+
+      return x;
+    }
+
+    // xScale returns card center. Adjust cardWidth in case of overlaping.
+    function getCardWidth(d) {
+      var w = void 0;
+      var cx = xScale(d.x);
+
+      if (cx < cardWidth / 2) {
+        // Center should not exceed half of card.
+        // Cut card to the left to prevent overlay of y axis.
+        var cutted_width = cx - cardSpacing / 2 + cardWidth / 2;
+        w = cutted_width > 0 ? cutted_width : 0;
+      } else if (chartWidth - cx < cardWidth / 2) {
+        // Cut card to the right to prevent overlay of right graph edge.
+        w = cardWidth / 2 + (chartWidth - cx - cardSpacing / 2);
+      } else {
+        w = cardWidth;
+      }
+
+      // Card width should be MIN_CARD_SIZE at least
+      w = Math.max(w, MIN_CARD_SIZE);
+
+      return w;
+    }
+
+    function getCardY(d) {
+      return yScale(d.y) + chartTop - cardHeight - cardSpacing / 2;
+    }
+
+    function getCardHeight(d) {
+      var ys = yScale(d.y);
+      var y = ys + chartTop - cardHeight - cardSpacing / 2;
+      var h = cardHeight;
+
+      // Cut card height to prevent overlay
+      if (y < chartTop) {
+        h = ys - cardSpacing / 2;
+      } else if (ys > chartBottom) {
+        h = chartBottom - y;
+      } else if (y + cardHeight > chartBottom) {
+        h = chartBottom - y;
+      }
+
+      // Height can't be more than chart height
+      h = Math.min(h, chartHeight);
+      // Card height should be MIN_CARD_SIZE at least
+      h = Math.max(h, MIN_CARD_SIZE);
+
+      return h;
+    }
+
+    function getCardColor(d) {
+      if (panel.color.mode === 'opacity') {
+        return panel.color.cardColor;
+      } else if (panel.color.mode === 'spectrum') {
+        return colorScale(d.value);
+      } else if (panel.color.mode === 'discrete') {
+        return ctrl.discreteHelper.getBucketColor(d.values);
+      }
+    }
+
+    function getCardOpacity(d) {
+      if (panel.nullPointMode === 'as empty' && d.value == null) {
+        return 0;
+      }
+      if (panel.color.mode === 'opacity') {
+        return opacityScale(d.value);
+      } else {
+        return 1;
+      }
+    }
+
+    function getCardStrokeWidth(d) {
+      if (panel.color.mode === 'discrete') {
+        return '1';
+      }
+      return '0';
+    }
+
+    /////////////////////////////
+    // Selection and crosshair //
+    /////////////////////////////
+
+    // Shared crosshair and tooltip
+    appEvents.on('graph-hover', function (event) {
+      drawSharedCrosshair(event.pos);
+    }, scope);
+
+    appEvents.on('graph-hover-clear', function () {
+      clearCrosshair();
+    }, scope);
+
+    function onMouseDown(event) {
+      selection.active = true;
+      selection.x1 = event.offsetX;
+
+      mouseUpHandler = function mouseUpHandler() {
+        onMouseUp();
+      };
+
+      $(document).one("mouseup", mouseUpHandler);
+    }
+
+    function onMouseUp() {
+      $(document).unbind("mouseup", mouseUpHandler);
+      mouseUpHandler = null;
+      selection.active = false;
+
+      var selectionRange = Math.abs(selection.x2 - selection.x1);
+      if (selection.x2 >= 0 && selectionRange > MIN_SELECTION_WIDTH) {
+        var timeFrom = xScale.invert(Math.min(selection.x1, selection.x2) - yAxisWidth - xGridSize / 2);
+        var timeTo = xScale.invert(Math.max(selection.x1, selection.x2) - yAxisWidth - xGridSize / 2);
+
+        ctrl.timeSrv.setTime({
+          from: moment.utc(timeFrom),
+          to: moment.utc(timeTo)
+        });
+      }
+
+      clearSelection();
+    }
+
+    function onMouseLeave() {
+      appEvents.emit('graph-hover-clear');
+      clearCrosshair();
+    }
+
+    function onMouseMove(event) {
+      if (!heatmap) {
+        return;
+      }
+
+      if (selection.active) {
+        // Clear crosshair and tooltip
+        clearCrosshair();
+        tooltip.destroy();
+
+        selection.x2 = limitSelection(event.offsetX);
+        drawSelection(selection.x1, selection.x2);
+      } else {
+        emitGraphHoverEvet(event);
+        drawCrosshair(event.offsetX);
+        tooltip.show(event); //, data);
+      }
+    }
+
+    function emitGraphHoverEvet(event) {
+      var x = xScale.invert(event.offsetX - yAxisWidth - xGridSize / 2).valueOf();
+      var y = yScale(event.offsetY);
+      var pos = {
+        pageX: event.pageX,
+        pageY: event.pageY,
+        x: x, x1: x,
+        y: y, y1: y,
+        panelRelY: null
+      };
+
+      // Set minimum offset to prevent showing legend from another panel
+      pos.panelRelY = Math.max(event.offsetY / height, 0.001);
+
+      // broadcast to other graph panels that we are hovering
+      appEvents.emit('graph-hover', { pos: pos, panel: panel });
+    }
+
+    function limitSelection(x2) {
+      x2 = Math.max(x2, yAxisWidth);
+      x2 = Math.min(x2, chartWidth + yAxisWidth);
+      return x2;
+    }
+
+    function drawSelection(posX1, posX2) {
+      if (heatmap) {
+        heatmap.selectAll(".status-heatmap-selection").remove();
+        var selectionX = Math.min(posX1, posX2);
+        var selectionWidth = Math.abs(posX1 - posX2);
+
+        if (selectionWidth > MIN_SELECTION_WIDTH) {
+          heatmap.append("rect").attr("class", "status-heatmap-selection").attr("x", selectionX).attr("width", selectionWidth).attr("y", chartTop).attr("height", chartHeight);
+        }
+      }
+    }
+
+    function clearSelection() {
+      selection.x1 = -1;
+      selection.x2 = -1;
+
+      if (heatmap) {
+        heatmap.selectAll(".status-heatmap-selection").remove();
+      }
+    }
+
+    function drawCrosshair(position) {
+      if (heatmap) {
+        heatmap.selectAll(".status-heatmap-crosshair").remove();
+
+        var posX = position;
+        posX = Math.max(posX, yAxisWidth);
+        posX = Math.min(posX, chartWidth + yAxisWidth);
+
+        heatmap.append("g").attr("class", "status-heatmap-crosshair").attr("transform", "translate(" + posX + ",0)").append("line").attr("x1", 1).attr("y1", chartTop).attr("x2", 1).attr("y2", chartBottom).attr("stroke-width", 1);
+      }
+    }
+
+    // map time to X
+    function drawSharedCrosshair(pos) {
+      if (heatmap && ctrl.dashboard.graphTooltip !== 0) {
+        var posX = xScale(pos.x) + yAxisWidth;
+        drawCrosshair(posX);
+      }
+    }
+
+    function clearCrosshair() {
+      if (heatmap) {
+        heatmap.selectAll(".status-heatmap-crosshair").remove();
+      }
+    }
+
+    function render() {
+      data = ctrl.data;
+      panel = ctrl.panel;
+      timeRange = ctrl.range;
+      cardsData = ctrl.cardsData;
+
+      if (!data || !cardsData || !setElementHeight()) {
+        return;
+      }
+
+      // Draw default axes and return if no data
+      if (_.isEmpty(cardsData.cards)) {
+        addHeatmapCanvas();
+        return;
+      }
+
+      addHeatmap();
+      scope.yAxisWidth = yAxisWidth;
+      scope.xAxisHeight = xAxisHeight;
+      scope.chartHeight = chartHeight;
+      scope.chartWidth = chartWidth;
+      scope.chartTop = chartTop;
+    }
+
+    // Register selection listeners
+    $heatmap.on("mousedown", onMouseDown);
+    $heatmap.on("mousemove", onMouseMove);
+    $heatmap.on("mouseleave", onMouseLeave);
+  }
+
+  _export('default', link);
+
+  function grafanaTimeFormat(ticks, min, max) {
+    if (min && max && ticks) {
+      var range = max - min;
+      var secPerTick = range / ticks / 1000;
+      var oneDay = 86400000;
+      var oneYear = 31536000000;
+
+      if (secPerTick <= 45) {
+        return "%H:%M:%S";
+      }
+      if (secPerTick <= 7200 || range <= oneDay) {
+        return "%H:%M";
+      }
+      if (secPerTick <= 80000) {
+        return "%m/%d %H:%M";
+      }
+      if (secPerTick <= 2419200 || range <= oneYear) {
+        return "%m/%d";
+      }
+      return "%Y-%m";
+    }
+
+    return "%H:%M";
+  }
+  return {
+    setters: [function (_lodash) {
+      _ = _lodash.default;
+    }, function (_jquery) {
+      $ = _jquery.default;
+    }, function (_moment) {
+      moment = _moment.default;
+    }, function (_appCoreUtilsKbn) {
+      kbn = _appCoreUtilsKbn.default;
+    }, function (_appCoreCore) {
+      appEvents = _appCoreCore.appEvents;
+      contextSrv = _appCoreCore.contextSrv;
+    }, function (_appCoreUtilsTicks) {
+      tickStep = _appCoreUtilsTicks.tickStep;
+      getScaledDecimals = _appCoreUtilsTicks.getScaledDecimals;
+      getFlotTickSize = _appCoreUtilsTicks.getFlotTickSize;
+    }, function (_d) {
+      d3 = _d.default;
+    }, function (_libsD3ScaleChromaticIndex) {
+      d3ScaleChromatic = _libsD3ScaleChromaticIndex;
+    }, function (_tooltip) {
+      StatusHeatmapTooltip = _tooltip.StatusHeatmapTooltip;
+    }],
+    execute: function () {
+      MIN_CARD_SIZE = 5;
+      CARD_SPACING = 2;
+      CARD_ROUND = 0;
+      DATA_RANGE_WIDING_FACTOR = 1.2;
+      DEFAULT_X_TICK_SIZE_PX = 100;
+      DEFAULT_Y_TICK_SIZE_PX = 50;
+      X_AXIS_TICK_PADDING = 10;
+      Y_AXIS_TICK_PADDING = 5;
+      MIN_SELECTION_WIDTH = 2;
+    }
+  };
+});
+//# sourceMappingURL=rendering.js.map

dist/status_heatmap_ctrl.js

@@ -0,0 +1,366 @@
+'use strict';
+
+System.register(['app/plugins/sdk', 'lodash', 'app/core/core', 'app/core/utils/kbn', './rendering', './options_editor', './color_mode_discrete', './css/status-heatmap.css!'], function (_export, _context) {
+  "use strict";
+
+  var MetricsPanelCtrl, _, contextSrv, kbn, rendering, statusHeatmapOptionsEditor, ColorModeDiscrete, CANVAS, SVG, VALUE_INDEX, TIME_INDEX, panelDefaults, renderer, colorSchemes, colorModes, opacityScales, StatusHeatmapCtrl;
+
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+
+  function _possibleConstructorReturn(self, call) {
+    if (!self) {
+      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+
+    return call && (typeof call === "object" || typeof call === "function") ? call : self;
+  }
+
+  function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+      throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+    }
+
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+      constructor: {
+        value: subClass,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+  }
+
+  return {
+    setters: [function (_appPluginsSdk) {
+      MetricsPanelCtrl = _appPluginsSdk.MetricsPanelCtrl;
+    }, function (_lodash) {
+      _ = _lodash.default;
+    }, function (_appCoreCore) {
+      contextSrv = _appCoreCore.contextSrv;
+    }, function (_appCoreUtilsKbn) {
+      kbn = _appCoreUtilsKbn.default;
+    }, function (_rendering) {
+      rendering = _rendering.default;
+    }, function (_options_editor) {
+      statusHeatmapOptionsEditor = _options_editor.statusHeatmapOptionsEditor;
+    }, function (_color_mode_discrete) {
+      ColorModeDiscrete = _color_mode_discrete.ColorModeDiscrete;
+    }, function (_cssStatusHeatmapCss) {}],
+    execute: function () {
+      CANVAS = 'CANVAS';
+      SVG = 'SVG';
+      VALUE_INDEX = 0;
+      TIME_INDEX = 1;
+      panelDefaults = {
+        // aggregate: aggregates.AVG,
+        // fragment: fragments.HOUR,
+        color: {
+          mode: 'spectrum',
+          cardColor: '#b4ff00',
+          colorScale: 'sqrt',
+          exponent: 0.5,
+          colorScheme: 'interpolateGnYlRd',
+          // discrete mode settings
+          defaultColor: '#757575',
+          thresholds: [] // manual colors
+        },
+        cards: {
+          cardMinWidth: 5,
+          cardSpacing: 2,
+          cardRound: null
+        },
+        xAxis: {
+          show: true,
+          showWeekends: true,
+          minBucketWidthToShowWeekends: 4,
+          showCrosshair: true,
+          labelFormat: '%a %m/%d'
+        },
+        yAxis: {
+          show: true,
+          showCrosshair: false
+        },
+        tooltip: {
+          show: true
+        },
+        legend: {
+          show: true
+        },
+        data: {
+          unitFormat: 'short',
+          decimals: null
+        },
+        // how null points should be handled
+        nullPointMode: 'as empty',
+        highlightCards: true,
+        useMax: true
+      };
+      renderer = CANVAS;
+      colorSchemes = [
+      // Diverging
+      { name: 'Spectral', value: 'interpolateSpectral', invert: 'always' }, { name: 'RdYlGn', value: 'interpolateRdYlGn', invert: 'always' }, { name: 'GnYlRd', value: 'interpolateGnYlRd', invert: 'always' },
+
+      // Sequential (Single Hue)
+      { name: 'Blues', value: 'interpolateBlues', invert: 'dark' }, { name: 'Greens', value: 'interpolateGreens', invert: 'dark' }, { name: 'Greys', value: 'interpolateGreys', invert: 'dark' }, { name: 'Oranges', value: 'interpolateOranges', invert: 'dark' }, { name: 'Purples', value: 'interpolatePurples', invert: 'dark' }, { name: 'Reds', value: 'interpolateReds', invert: 'dark' },
+
+      // Sequential (Multi-Hue)
+      { name: 'BuGn', value: 'interpolateBuGn', invert: 'dark' }, { name: 'BuPu', value: 'interpolateBuPu', invert: 'dark' }, { name: 'GnBu', value: 'interpolateGnBu', invert: 'dark' }, { name: 'OrRd', value: 'interpolateOrRd', invert: 'dark' }, { name: 'PuBuGn', value: 'interpolatePuBuGn', invert: 'dark' }, { name: 'PuBu', value: 'interpolatePuBu', invert: 'dark' }, { name: 'PuRd', value: 'interpolatePuRd', invert: 'dark' }, { name: 'RdPu', value: 'interpolateRdPu', invert: 'dark' }, { name: 'YlGnBu', value: 'interpolateYlGnBu', invert: 'dark' }, { name: 'YlGn', value: 'interpolateYlGn', invert: 'dark' }, { name: 'YlOrBr', value: 'interpolateYlOrBr', invert: 'dark' }, { name: 'YlOrRd', value: 'interpolateYlOrRd', invert: 'darm' }];
+      colorModes = ['opacity', 'spectrum', 'discrete'];
+      opacityScales = ['linear', 'sqrt'];
+
+      _export('StatusHeatmapCtrl', StatusHeatmapCtrl = function (_MetricsPanelCtrl) {
+        _inherits(StatusHeatmapCtrl, _MetricsPanelCtrl);
+
+        function StatusHeatmapCtrl($scope, $injector, $rootScope, timeSrv) {
+          _classCallCheck(this, StatusHeatmapCtrl);
+
+          var _this = _possibleConstructorReturn(this, (StatusHeatmapCtrl.__proto__ || Object.getPrototypeOf(StatusHeatmapCtrl)).call(this, $scope, $injector));
+
+          _this.onRenderComplete = function (data) {
+            _this.graph.chartWidth = data.chartWidth;
+          };
+
+          _this.calculateInterval = function () {
+            var panelWidth = Math.ceil($(window).width() * (_this.panel.gridPos.w / 24));
+            // approximate chartWidth because y axis ticks not rendered yet on first data receive.
+            var chartWidth = _.max([panelWidth - 200, panelWidth / 2]);
+
+            var minCardWidth = _this.panel.cards.cardMinWidth;
+            var minSpacing = _this.panel.cards.cardSpacing;
+            var maxCardsCount = Math.ceil((chartWidth - minCardWidth) / (minCardWidth + minSpacing));
+
+            var intervalMs = void 0;
+            var rangeMs = _this.range.to.valueOf() - _this.range.from.valueOf();
+
+            // this is minimal interval! kbn.round_interval will lower it.
+            intervalMs = _this.discreteHelper.roundIntervalCeil(rangeMs / maxCardsCount);
+
+            // Calculate low limit of interval
+            var lowLimitMs = 1; // 1 millisecond default low limit
+            var intervalOverride = _this.panel.interval;
+
+            // if no panel interval check datasource
+            if (intervalOverride) {
+              intervalOverride = _this.templateSrv.replace(intervalOverride, _this.panel.scopedVars);
+            } else if (_this.datasource && _this.datasource.interval) {
+              intervalOverride = _this.datasource.interval;
+            }
+
+            if (intervalOverride) {
+              if (intervalOverride[0] === '>') {
+                intervalOverride = intervalOverride.slice(1);
+              }
+              lowLimitMs = kbn.interval_to_ms(intervalOverride);
+            }
+
+            if (lowLimitMs > intervalMs) {
+              intervalMs = lowLimitMs;
+            }
+
+            _this.intervalMs = intervalMs;
+            _this.interval = kbn.secondsToHms(intervalMs / 1000);
+          };
+
+          _this.onDataReceived = function (dataList) {
+            _this.data = dataList;
+            _this.cardsData = _this.convertToCards(_this.data);
+
+            _this.render();
+          };
+
+          _this.onInitEditMode = function () {
+            _this.addEditorTab('Options', statusHeatmapOptionsEditor, 2);
+            _this.unitFormats = kbn.getUnitFormats();
+          };
+
+          _this.onRender = function () {
+            if (!_this.data) {
+              return;
+            }
+
+            _this.multipleValues = false;
+            if (!_this.panel.useMax) {
+              if (_this.cardsData) {
+                _this.multipleValues = _this.cardsData.multipleValues;
+              }
+            }
+
+            _this.noColorDefined = false;
+            if (_this.panel.color.mode === 'discrete') {
+              _this.discreteHelper.updateCardsValuesHasColorInfo();
+              if (_this.cardsData) {
+                _this.noColorDefined = _this.cardsData.noColorDefined;
+              }
+            }
+          };
+
+          _this.onCardColorChange = function (newColor) {
+            _this.panel.color.cardColor = newColor;
+            _this.render();
+          };
+
+          _this.onDataError = function () {
+            _this.data = [];
+            _this.render();
+          };
+
+          _this.postRefresh = function () {
+            _this.noColorDefined = false;
+          };
+
+          _this.onEditorAddThreshold = function () {
+            _this.panel.color.thresholds.push({ color: _this.panel.defaultColor });
+            _this.render();
+          };
+
+          _this.onEditorRemoveThreshold = function (index) {
+            _this.panel.color.thresholds.splice(index, 1);
+            _this.render();
+          };
+
+          _this.onEditorAddThreeLights = function () {
+            _this.panel.color.thresholds.push({ color: "red", value: 2, tooltip: "error" });
+            _this.panel.color.thresholds.push({ color: "yellow", value: 1, tooltip: "warning" });
+            _this.panel.color.thresholds.push({ color: "green", value: 0, tooltip: "ok" });
+            _this.render();
+          };
+
+          _this.link = function (scope, elem, attrs, ctrl) {
+            rendering(scope, elem, attrs, ctrl);
+          };
+
+          _this.convertToCards = function (data) {
+            var cardsData = {
+              cards: [],
+              xBucketSize: 0,
+              yBucketSize: 0,
+              maxValue: 0,
+              minValue: 0,
+              multipleValues: false,
+              noColorDefined: false
+            };
+
+            if (!data || data.length == 0) {
+              return cardsData;
+            }
+
+            // collect uniq targets and their indexes in data array
+            cardsData.targetIndex = {};
+            for (var i = 0; i < data.length; i++) {
+              var ts = data[i];
+              var target = ts.target;
+              if (cardsData.targetIndex[target] == undefined) {
+                cardsData.targetIndex[target] = [];
+              }
+              cardsData.targetIndex[target].push(i);
+            }
+
+            // TODO add some logic for targets heirarchy
+            cardsData.targets = _.keys(cardsData.targetIndex);
+            cardsData.targets.sort();
+            cardsData.yBucketSize = cardsData.targets.length;
+            cardsData.xBucketSize = _.min(_.map(data, function (d) {
+              return d.datapoints.length;
+            }));
+
+            // Collect all values for each bucket from datapoints with similar target.
+            for (var _i = 0; _i < cardsData.targets.length; _i++) {
+              var _target = cardsData.targets[_i];
+
+              for (var j = 0; j < cardsData.xBucketSize; j++) {
+                var card = {
+                  id: _i * cardsData.xBucketSize + j,
+                  values: [],
+                  multipleValues: false,
+                  noColorDefined: false
+                };
+
+                // collect values from all timeseries with target
+                for (var si = 0; si < cardsData.targetIndex[_target].length; si++) {
+                  var s = data[cardsData.targetIndex[_target][si]];
+                  var datapoint = s.datapoints[j];
+                  if (card.values.length === 0) {
+                    card.x = datapoint[TIME_INDEX];
+                    card.y = s.target;
+                  }
+                  card.values.push(datapoint[VALUE_INDEX]);
+                }
+                card.minValue = _.min(card.values);
+                card.maxValue = _.max(card.values);
+                if (card.values.length > 1) {
+                  cardsData.multipleValues = true;
+                  card.multipleValues = true;
+                  card.value = card.maxValue; // max value by default
+                } else {
+                  card.value = card.maxValue; // max value by default
+                }
+
+                if (cardsData.maxValue < card.maxValue) cardsData.maxValue = card.maxValue;
+
+                if (cardsData.minValue > card.minValue) cardsData.minValue = card.minValue;
+
+                cardsData.cards.push(card);
+              }
+            }
+
+            return cardsData;
+          };
+
+          _.defaultsDeep(_this.panel, panelDefaults);
+
+          _this.opacityScales = opacityScales;
+          _this.colorModes = colorModes;
+          _this.colorSchemes = colorSchemes;
+
+          // default graph width for discrete card width calculation
+          _this.graph = {
+            "chartWidth": -1
+          };
+
+          _this.multipleValues = false;
+          _this.noColorDefined = false;
+
+          _this.discreteHelper = new ColorModeDiscrete($scope);
+
+          _this.dataWarnings = {
+            "noColorDefined": {
+              title: 'Data has value with undefined color',
+              tip: 'Check metric values, color values or define a new color'
+            },
+            "multipleValues": {
+              title: 'Data has multiple values for one target',
+              tip: 'Change targets definitions or set "use max value"'
+            }
+          };
+
+          _this.events.on('data-received', _this.onDataReceived);
+          _this.events.on('data-snapshot-load', _this.onDataReceived);
+          _this.events.on('data-error', _this.onDataError);
+          _this.events.on('init-edit-mode', _this.onInitEditMode);
+          _this.events.on('render', _this.onRender);
+          _this.events.on('refresh', _this.postRefresh);
+          _this.events.on('render-complete', _this.onRenderComplete);
+          return _this;
+        }
+
+        // override calculateInterval for discrete color mode
+
+
+        // group values into buckets by target
+
+
+        return StatusHeatmapCtrl;
+      }(MetricsPanelCtrl));
+
+      _export('StatusHeatmapCtrl', StatusHeatmapCtrl);
+
+      StatusHeatmapCtrl.templateUrl = 'module.html';
+    }
+  };
+});
+//# sourceMappingURL=status_heatmap_ctrl.js.map

dist/tooltip.js

@@ -0,0 +1,206 @@
+'use strict';
+
+System.register(['d3', 'jquery', 'lodash', 'app/core/utils/kbn'], function (_export, _context) {
+  "use strict";
+
+  var d3, $, _, kbn, _createClass, TOOLTIP_PADDING_X, TOOLTIP_PADDING_Y, StatusHeatmapTooltip;
+
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+
+  return {
+    setters: [function (_d) {
+      d3 = _d.default;
+    }, function (_jquery) {
+      $ = _jquery.default;
+    }, function (_lodash) {
+      _ = _lodash.default;
+    }, function (_appCoreUtilsKbn) {
+      kbn = _appCoreUtilsKbn.default;
+    }],
+    execute: function () {
+      _createClass = function () {
+        function defineProperties(target, props) {
+          for (var i = 0; i < props.length; i++) {
+            var descriptor = props[i];
+            descriptor.enumerable = descriptor.enumerable || false;
+            descriptor.configurable = true;
+            if ("value" in descriptor) descriptor.writable = true;
+            Object.defineProperty(target, descriptor.key, descriptor);
+          }
+        }
+
+        return function (Constructor, protoProps, staticProps) {
+          if (protoProps) defineProperties(Constructor.prototype, protoProps);
+          if (staticProps) defineProperties(Constructor, staticProps);
+          return Constructor;
+        };
+      }();
+
+      TOOLTIP_PADDING_X = 30;
+      TOOLTIP_PADDING_Y = 5;
+
+      _export('StatusHeatmapTooltip', StatusHeatmapTooltip = function () {
+        function StatusHeatmapTooltip(elem, scope) {
+          _classCallCheck(this, StatusHeatmapTooltip);
+
+          this.scope = scope;
+          this.dashboard = scope.ctrl.dashboard;
+          this.panelCtrl = scope.ctrl;
+          this.panel = scope.ctrl.panel;
+          this.heatmapPanel = elem;
+          this.mouseOverBucket = false;
+          this.originalFillColor = null;
+
+          elem.on("mouseover", this.onMouseOver.bind(this));
+          elem.on("mouseleave", this.onMouseLeave.bind(this));
+        }
+
+        _createClass(StatusHeatmapTooltip, [{
+          key: 'onMouseOver',
+          value: function onMouseOver(e) {
+            if (!this.panel.tooltip.show || !this.scope.ctrl.data || _.isEmpty(this.scope.ctrl.data)) {
+              return;
+            }
+
+            if (!this.tooltip) {
+              this.add();
+              this.move(e);
+            }
+          }
+        }, {
+          key: 'onMouseLeave',
+          value: function onMouseLeave() {
+            this.destroy();
+          }
+        }, {
+          key: 'onMouseMove',
+          value: function onMouseMove(e) {
+            if (!this.panel.tooltip.show) {
+              return;
+            }
+
+            this.move(e);
+          }
+        }, {
+          key: 'add',
+          value: function add() {
+            this.tooltip = d3.select("body").append("div").attr("class", "heatmap-tooltip graph-tooltip grafana-tooltip");
+          }
+        }, {
+          key: 'destroy',
+          value: function destroy() {
+            if (this.tooltip) {
+              this.tooltip.remove();
+            }
+
+            this.tooltip = null;
+          }
+        }, {
+          key: 'show',
+          value: function show(pos) {
+            if (!this.panel.tooltip.show || !this.tooltip) {
+              return;
+            }
+            // shared tooltip mode
+            if (pos.panelRelY) {
+              return;
+            }
+            var cardId = d3.select(pos.target).attr('cardId');
+            if (!cardId) {
+              this.destroy();
+              return;
+            }
+
+            var card = this.panelCtrl.cardsData.cards[cardId];
+            if (!card) {
+              this.destroy();
+              return;
+            }
+
+            var x = card.x;
+            var y = card.y;
+            var value = card.value;
+            var values = card.values;
+            var tooltipTimeFormat = 'YYYY-MM-DD HH:mm:ss';
+            var time = this.dashboard.formatDate(+x, tooltipTimeFormat);
+
+            var tooltipHtml = '<div class="graph-tooltip-time">' + time + '</div>\n      <div class="status-heatmap-histogram"></div>';
+
+            if (this.panel.color.mode === 'discrete') {
+              var statuses = this.panelCtrl.discreteHelper.convertValuesToTooltips(values);
+              var statusesHtml = '';
+              if (statuses.length === 1) {
+                statusesHtml = "status:";
+              } else if (statuses.length > 1) {
+                statusesHtml = "statuses:";
+              }
+              tooltipHtml += '\n      <div>\n        name: <b>' + y + '</b> <br>\n        ' + statusesHtml + '\n        <ul>\n          ' + _.join(_.map(statuses, function (v) {
+                return '<li style="background-color: ' + v.color + '; padding: 1px; font-weight: bold; text-shadow: 0 0 0.2em #FFF, 0 0 0.2em #FFF, 0 0 0.2em #FFF">' + v.tooltip + '</li>';
+              }), "") + '\n        </ul>\n      </div>';
+            } else {
+              if (values.length === 1) {
+                tooltipHtml += '<div> \n      name: <b>' + y + '</b> <br>\n      value: <b>' + value + '</b> <br>\n      </div>';
+              } else {
+                tooltipHtml += '<div>\n      name: <b>' + y + '</b> <br>\n      values:\n      <ul>\n        ' + _.join(_.map(values, function (v) {
+                  return '<li>' + v + '</li>';
+                }), "") + '\n      </ul>\n      </div>';
+              }
+            }
+
+            //   "Ambiguous bucket state: Multiple values!";
+            if (!this.panel.useMax && card.multipleValues) {
+              tooltipHtml += '<div><b>Error:</b> ' + this.panelCtrl.dataWarnings.multipleValues.title + '</div>';
+            }
+
+            // Discrete mode errors
+            if (this.panel.color.mode === 'discrete') {
+              if (card.noColorDefined) {
+                var badValues = this.panelCtrl.discreteHelper.getNotColoredValues(values);
+                tooltipHtml += '<div><b>Error:</b> ' + this.panelCtrl.dataWarnings.noColorDefined.title + '\n        <br>not colored values:\n        <ul>\n          ' + _.join(_.map(badValues, function (v) {
+                  return '<li>' + v + '</li>';
+                }), "") + '\n        </ul>\n        </div>';
+              }
+            }
+
+            this.tooltip.html(tooltipHtml);
+
+            this.move(pos);
+          }
+        }, {
+          key: 'move',
+          value: function move(pos) {
+            if (!this.tooltip) {
+              return;
+            }
+
+            var elem = $(this.tooltip.node())[0];
+            var tooltipWidth = elem.clientWidth;
+            var tooltipHeight = elem.clientHeight;
+
+            var left = pos.pageX + TOOLTIP_PADDING_X;
+            var top = pos.pageY + TOOLTIP_PADDING_Y;
+
+            if (pos.pageX + tooltipWidth + 40 > window.innerWidth) {
+              left = pos.pageX - tooltipWidth - TOOLTIP_PADDING_X;
+            }
+
+            if (pos.pageY - window.pageYOffset + tooltipHeight + 20 > window.innerHeight) {
+              top = pos.pageY - tooltipHeight - TOOLTIP_PADDING_Y;
+            }
+
+            return this.tooltip.style("left", left + "px").style("top", top + "px");
+          }
+        }]);
+
+        return StatusHeatmapTooltip;
+      }());
+
+      _export('StatusHeatmapTooltip', StatusHeatmapTooltip);
+    }
+  };
+});
+//# sourceMappingURL=tooltip.js.map