@semcore/d3-chart 2.2.7 → 2.3.1

package/lib/es6/a11y/insights.js

@@ -0,0 +1,779 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _typeof from "@babel/runtime/helpers/typeof";
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+import { makeBezier } from './bezier';
+
+var getPropByPath = function getPropByPath(obj, path) {
+  if (typeof path === 'number') path = String(path);
+  if (typeof path === 'string') path = path.split('.');
+
+  for (var i = 0; i < path.length; i++) {
+    if (_typeof(obj) !== 'object' || obj === null) return obj;
+    obj = obj[path[i]];
+  }
+
+  return obj;
+};
+
+var movingAverage = function movingAverage(data, frame) {
+  var result = [];
+  frame = Math.floor(frame) % 2 === data.length % 2 ? Math.floor(frame) : Math.ceil(frame);
+
+  for (var i = 0; i < data.length; i++) {
+    var startIndex = Math.max(0, i - Math.floor(frame / 2));
+    var endIndex = Math.min(data.length, i + Math.ceil(frame / 2));
+    startIndex = Math.min(startIndex, Math.max(0, endIndex - frame));
+    endIndex = Math.max(endIndex, Math.min(data.length, startIndex + frame));
+    var part = data.slice(startIndex, endIndex);
+    var sum = part.reduce(function (sum, item) {
+      return sum + item;
+    }, 0);
+    var value = sum / part.length;
+    result.push(value);
+  }
+
+  return result;
+};
+
+export var extractDataInsights = function extractDataInsights(data, hints, config) {
+  var _config$dataType, _hints$axesTitle$vert, _ref;
+
+  var insights = [];
+  var dataType = (_config$dataType = config.dataType) !== null && _config$dataType !== void 0 ? _config$dataType : hints.dataType;
+  var dataRange = [];
+
+  var groupKeys = _toConsumableArray(hints.groups);
+
+  var dataTitle = (_hints$axesTitle$vert = hints.axesTitle.vertical) !== null && _hints$axesTitle$vert !== void 0 ? _hints$axesTitle$vert : hints.axesTitle.horizontal;
+  var entitiesCount = 0;
+  var keysMap = Object.fromEntries(Object.keys((_ref = Array.isArray(data) ? data[0] : data) !== null && _ref !== void 0 ? _ref : {}).map(function (key) {
+    return [key, true];
+  }));
+
+  if (!dataType) {
+    if ((keysMap['y'] || keysMap['y1'] || keysMap['y2']) && keysMap['x'] && (keysMap['value'] || keysMap['label']) || hints.fields.horizontalAxes.size > 0 && hints.fields.verticalAxes.size > 0 && hints.fields.valueAxes.size > 0) {
+      dataType = 'points-cloud';
+    } else if (Array.isArray(data) && data.length > 6) {
+      dataType = 'time-series';
+    } else if (Array.isArray(data) && Object.keys(keysMap).length >= 3) {
+      var possibleGroupKeys = Object.keys(keysMap).filter(function (key) {
+        return typeof data[0][key] === 'string';
+      }).filter(function (key) {
+        var allData = data.map(function (row) {
+          return row[key];
+        });
+        return new Set(allData).size === allData.length;
+      });
+
+      if (possibleGroupKeys.length === 1) {
+        groupKeys = possibleGroupKeys;
+        dataType = 'grouped-values';
+      } else {
+        dataType = 'values-set';
+      }
+    } else {
+      dataType = 'values-set';
+    }
+  }
+
+  if (dataType === 'grouped-values' && groupKeys.length === 0) {
+    dataType = 'values-set';
+  }
+
+  if (Array.isArray(data)) {
+    if (dataType === 'time-series') {
+      var _ref2, _hints$titles$getHori, _hints$titles$getHori2, _hints$titles, _ref3, _hints$titles$getHori3, _hints$titles$getHori4, _hints$titles2;
+
+      var firstRow = data[0];
+      var lastRow = data[data.length - 1];
+      var possibleValueKeys = ['y', 'value'].concat(_toConsumableArray(hints.fields.verticalAxes));
+      var valuesKeys = possibleValueKeys.filter(function (key) {
+        return keysMap[key];
+      });
+      var possibleLabelKeys = ['label', 'x'].concat(_toConsumableArray(hints.fields.horizontalAxes));
+      var labelsKey = possibleLabelKeys.filter(function (key) {
+        return keysMap[key];
+      })[0];
+      entitiesCount = Object.keys(valuesKeys).length;
+      var fromKey = firstRow[labelsKey];
+      var toKey = lastRow[labelsKey];
+      var from = (_ref2 = (_hints$titles$getHori = (_hints$titles$getHori2 = (_hints$titles = hints.titles).getHorizontalAxesTitle) === null || _hints$titles$getHori2 === void 0 ? void 0 : _hints$titles$getHori2.call(_hints$titles, fromKey)) !== null && _hints$titles$getHori !== void 0 ? _hints$titles$getHori : hints.titles.horizontalAxes[fromKey]) !== null && _ref2 !== void 0 ? _ref2 : fromKey;
+      var to = (_ref3 = (_hints$titles$getHori3 = (_hints$titles$getHori4 = (_hints$titles2 = hints.titles).getHorizontalAxesTitle) === null || _hints$titles$getHori4 === void 0 ? void 0 : _hints$titles$getHori4.call(_hints$titles2, toKey)) !== null && _hints$titles$getHori3 !== void 0 ? _hints$titles$getHori3 : hints.titles.horizontalAxes[toKey]) !== null && _ref3 !== void 0 ? _ref3 : toKey;
+
+      if (entitiesCount > 0) {
+        var _hints$axesTitle$vert2;
+
+        dataRange.push({
+          from: from,
+          to: to,
+          label: (_hints$axesTitle$vert2 = hints.axesTitle.vertical) !== null && _hints$axesTitle$vert2 !== void 0 ? _hints$axesTitle$vert2 : labelsKey
+        });
+      }
+
+      var _iterator = _createForOfIteratorHelper(valuesKeys),
+          _step;
+
+      try {
+        var _loop = function _loop() {
+          var _config$movingAverage, _config$movingAverage2, _insights;
+
+          var valueKey = _step.value;
+          var values = data.map(function (row) {
+            return row[valueKey];
+          });
+          var sum = values.reduce(function (sum, value) {
+            return sum += value;
+          }, 0);
+          var average = sum / values.length;
+          var variance = 1 / values.length * values.map(function (value) {
+            return Math.pow(value - average, 2);
+          }).reduce(function (sum, item) {
+            return sum + item;
+          }, 0);
+          var standardDeviation = Math.sqrt(variance);
+          var trendStrengths = ['static', 'weak', 'medium', 'strong'];
+          var frameSize = Math.sqrt(values.length);
+          var longMovingAverageSize = (_config$movingAverage = config.movingAverage.longSize) !== null && _config$movingAverage !== void 0 ? _config$movingAverage : frameSize;
+          var shortMovingAverageSize = (_config$movingAverage2 = config.movingAverage.shortSize) !== null && _config$movingAverage2 !== void 0 ? _config$movingAverage2 : Math.sqrt(frameSize);
+          var longMovingAverage = movingAverage(values, longMovingAverageSize);
+          var shortMovingAverage = values.length < 8 ? values : movingAverage(values, shortMovingAverageSize);
+          var table = [];
+
+          for (var i in values) {
+            var _longMovingAverage$i, _shortMovingAverage$i;
+
+            table.push({
+              value: values[i].toFixed(2),
+              "long": ((_longMovingAverage$i = longMovingAverage[i]) !== null && _longMovingAverage$i !== void 0 ? _longMovingAverage$i : NaN).toFixed(2),
+              "short": ((_shortMovingAverage$i = shortMovingAverage[i]) !== null && _shortMovingAverage$i !== void 0 ? _shortMovingAverage$i : NaN).toFixed(2)
+            });
+          }
+
+          var strengthsMap = {
+            growth: {
+              "static": 'static',
+              weak: 'weak-growth',
+              medium: 'growth',
+              strong: 'strong-growth'
+            },
+            reduction: {
+              "static": 'static',
+              weak: 'weak-reduction',
+              medium: 'reduction',
+              strong: 'strong-reduction'
+            }
+          };
+
+          var recordTrend = function recordTrend(_ref4) {
+            var value = _ref4.value,
+                width = _ref4.width,
+                label = _ref4.label,
+                type = _ref4.type;
+
+            for (var _i = 0; _i < trendStrengths.length; _i++) {
+              var _hints$pointsDensity$, _hints$pointsDensity, _hints$pointsDensity$2, _hints$pointsDensity2;
+
+              var normalizedHeight = Math.abs(value.from - value.to) / ((_hints$pointsDensity$ = (_hints$pointsDensity = hints.pointsDensity) === null || _hints$pointsDensity === void 0 ? void 0 : _hints$pointsDensity.verticalAxes) !== null && _hints$pointsDensity$ !== void 0 ? _hints$pointsDensity$ : 1);
+              var normalizedWidth = width / ((_hints$pointsDensity$2 = (_hints$pointsDensity2 = hints.pointsDensity) === null || _hints$pointsDensity2 === void 0 ? void 0 : _hints$pointsDensity2.horizontalAxes) !== null && _hints$pointsDensity$2 !== void 0 ? _hints$pointsDensity$2 : 1);
+              var tang = normalizedHeight / normalizedWidth;
+              var trendStrength = trendStrengths[_i];
+
+              if (tang <= config.trendTangens[trendStrength] || _i === trendStrengths.length - 1) {
+                var strength = value.to > value.from ? strengthsMap.growth[trendStrength] : strengthsMap.reduction[trendStrength];
+                return {
+                  type: type,
+                  priority: _i,
+                  change: {
+                    from: value.from,
+                    to: value.to,
+                    strength: strength
+                  },
+                  from: label.from,
+                  to: label.to,
+                  dataKey: label.dataKey
+                };
+              }
+            }
+          };
+
+          var generalTrend = recordTrend({
+            type: 'general-trend',
+            value: {
+              from: shortMovingAverage[0],
+              to: shortMovingAverage[shortMovingAverage.length - 1]
+            },
+            width: data.length,
+            label: {
+              from: from,
+              to: to,
+              dataKey: valueKey
+            }
+          });
+          var localTrends = [];
+          {
+            var _config$movingAverage3;
+
+            var notableDiff = (_config$movingAverage3 = config.movingAverage.notableDiff) !== null && _config$movingAverage3 !== void 0 ? _config$movingAverage3 : standardDeviation / 10;
+            var lastSwitch = 0;
+            var lastSwitchValue = shortMovingAverage[lastSwitch];
+            var shortWasAbove = shortMovingAverage[0] > longMovingAverage[0];
+
+            for (var _i2 = 1; _i2 < data.length; _i2++) {
+              var _ref5, _hints$titles$getHori5, _hints$titles$getHori6, _hints$titles3, _ref6, _hints$titles$getHori7, _hints$titles$getHori8, _hints$titles4;
+
+              var shortIsAbove = shortMovingAverage[_i2] > longMovingAverage[_i2];
+              var diff = Math.abs(shortMovingAverage[_i2] - longMovingAverage[_i2]);
+              if (shortIsAbove === shortWasAbove) continue;
+              if (diff < notableDiff) continue;
+              if (_i2 === 0 && lastSwitch === data.length - 1) continue;
+              if (_i2 === data.length - 1 && lastSwitch === 0) continue;
+              _i2 = Math.min(_i2, data.length - 1);
+              var _fromKey = data[lastSwitch][labelsKey];
+              var _toKey = data[_i2][labelsKey];
+
+              var _from = (_ref5 = (_hints$titles$getHori5 = (_hints$titles$getHori6 = (_hints$titles3 = hints.titles).getHorizontalAxesTitle) === null || _hints$titles$getHori6 === void 0 ? void 0 : _hints$titles$getHori6.call(_hints$titles3, _fromKey)) !== null && _hints$titles$getHori5 !== void 0 ? _hints$titles$getHori5 : hints.titles.horizontalAxes[_fromKey]) !== null && _ref5 !== void 0 ? _ref5 : _fromKey;
+
+              var _to = (_ref6 = (_hints$titles$getHori7 = (_hints$titles$getHori8 = (_hints$titles4 = hints.titles).getHorizontalAxesTitle) === null || _hints$titles$getHori8 === void 0 ? void 0 : _hints$titles$getHori8.call(_hints$titles4, _toKey)) !== null && _hints$titles$getHori7 !== void 0 ? _hints$titles$getHori7 : hints.titles.horizontalAxes[_toKey]) !== null && _ref6 !== void 0 ? _ref6 : _toKey;
+
+              localTrends.push(recordTrend({
+                type: 'trend',
+                value: {
+                  from: lastSwitchValue,
+                  to: shortMovingAverage[_i2]
+                },
+                width: _i2 - lastSwitch,
+                label: {
+                  from: _from,
+                  to: _to,
+                  dataKey: valueKey
+                }
+              }));
+              lastSwitch = _i2;
+              lastSwitchValue = shortMovingAverage[lastSwitch];
+              shortWasAbove = shortIsAbove;
+            }
+
+            if (lastSwitch !== 0) {
+              var lastIndex = shortMovingAverage.length - 1;
+              var lastValue = shortMovingAverage[lastIndex];
+
+              if (Math.abs(lastSwitchValue - lastValue) > notableDiff) {
+                localTrends.push(recordTrend({
+                  type: 'trend',
+                  value: {
+                    from: lastSwitchValue,
+                    to: lastValue
+                  },
+                  width: lastIndex - lastSwitch,
+                  label: {
+                    from: data[lastSwitch][labelsKey],
+                    to: data[lastIndex][labelsKey],
+                    dataKey: valueKey
+                  }
+                }));
+              }
+            }
+          }
+          insights.push(generalTrend);
+
+          (_insights = insights).push.apply(_insights, localTrends);
+        };
+
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          _loop();
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    } else if (dataType === 'points-cloud') {
+      var _ref7, _config$clustersGridS, _relativeSizeDistrivu, _insights2;
+
+      var guessedXKey = [].concat(_toConsumableArray(hints.fields.horizontalAxes.values()), ['x'])[0];
+      var guessedYKey = [].concat(_toConsumableArray(hints.fields.verticalAxes.values()), ['y'])[0];
+      var guessedValueKey = [].concat(_toConsumableArray(hints.fields.valueAxes.values()), ['value'])[0];
+      var guessedLabelKey = keysMap['label'] ? 'label' : guessedValueKey;
+      var normalized = data.map(function (row) {
+        return {
+          x: row[guessedXKey],
+          y: row[guessedYKey],
+          label: row[guessedLabelKey],
+          value: row[guessedValueKey]
+        };
+      });
+      var gridSize = (_ref7 = (_config$clustersGridS = config.clustersGridSize) !== null && _config$clustersGridS !== void 0 ? _config$clustersGridS : hints.grid.verticalAxes) !== null && _ref7 !== void 0 ? _ref7 : hints.grid.horizontalAxes;
+
+      if (!gridSize) {
+        var usedX = new Set();
+        var usedY = new Set();
+
+        var _iterator2 = _createForOfIteratorHelper(normalized),
+            _step2;
+
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var _step2$value = _step2.value,
+                _x = _step2$value.x,
+                _y = _step2$value.y;
+            usedX.add(_x);
+            usedY.add(_y);
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+
+        var orderedX = _toConsumableArray(usedX).sort(function (a, b) {
+          return a - b;
+        });
+
+        var orderedY = _toConsumableArray(usedY).sort(function (a, b) {
+          return a - b;
+        });
+
+        var distancesX = orderedX.slice(0, -1).map(function (x, index) {
+          return orderedX[index + 1] - x;
+        });
+        var distancesY = orderedY.slice(0, -1).map(function (y, index) {
+          return orderedY[index + 1] - y;
+        });
+        var avgDistanceX = distancesX.reduce(function (sum, x) {
+          return sum + x;
+        }, 0) / distancesX.length;
+        var avgDistanceY = distancesY.reduce(function (sum, y) {
+          return sum + y;
+        }, 0) / distancesY.length;
+        var belowAvgDistancesX = distancesX.filter(function (x) {
+          return x < avgDistanceX;
+        });
+        var belowAvgDistancesY = distancesY.filter(function (y) {
+          return y < avgDistanceY;
+        });
+        var betweenDistanceX = belowAvgDistancesX.reduce(function (sum, x) {
+          return sum + x;
+        }, 0) / belowAvgDistancesX.length;
+        var betweenDistanceY = belowAvgDistancesY.reduce(function (sum, y) {
+          return sum + y;
+        }, 0) / belowAvgDistancesY.length;
+        var avgDistance = 0;
+
+        if (!Number.isNaN(betweenDistanceX) && !Number.isNaN(betweenDistanceY)) {
+          avgDistance = (betweenDistanceX + betweenDistanceY) / 2;
+        } else if (!Number.isNaN(betweenDistanceX)) {
+          avgDistance = betweenDistanceX;
+        } else if (!Number.isNaN(betweenDistanceY)) {
+          avgDistance = betweenDistanceY;
+        } else {
+          avgDistance = (avgDistanceX + avgDistanceY) / 2;
+        }
+
+        gridSize = Math.sqrt(Math.sqrt(avgDistance));
+      }
+
+      var grid = {};
+      var takenY = new Set();
+      var takenX = new Set();
+
+      for (var i = 0; i < normalized.length; i++) {
+        var _grid$gridX, _grid$gridX$gridY;
+
+        var _normalized$i = normalized[i],
+            _x2 = _normalized$i.x,
+            _y2 = _normalized$i.y;
+        var gridX = Math.round(_x2 / gridSize);
+        var gridY = Math.round(_y2 / gridSize);
+        takenY.add(_y2);
+        takenX.add(_x2);
+        grid[gridX] = (_grid$gridX = grid[gridX]) !== null && _grid$gridX !== void 0 ? _grid$gridX : {};
+        grid[gridX][gridY] = (_grid$gridX$gridY = grid[gridX][gridY]) !== null && _grid$gridX$gridY !== void 0 ? _grid$gridX$gridY : {
+          clusterId: "".concat(gridX, "_").concat(gridY),
+          members: []
+        };
+        grid[gridX][gridY].members.push(normalized[i]);
+      }
+
+      var clusters = {};
+
+      var _iterator3 = _createForOfIteratorHelper(Object.keys(grid).map(function (x) {
+        return parseInt(x, 10);
+      })),
+          _step3;
+
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var _x4 = _step3.value;
+
+          var _iterator4 = _createForOfIteratorHelper(Object.keys(grid[_x4]).map(function (y) {
+            return parseInt(y, 10);
+          })),
+              _step4;
+
+          try {
+            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+              var _clusters$grid$_x4$_y, _clusters$grid$_x4$_y2;
+
+              var _y4 = _step4.value;
+              var pointHandled = false;
+
+              for (var _i4 = 0, _arr = [_x4 - 1, _x4, _x4 + 1]; _i4 < _arr.length; _i4++) {
+                var xNeighbour = _arr[_i4];
+
+                for (var _i5 = 0, _arr2 = [_y4 - 1, _y4, _y4 + 1]; _i5 < _arr2.length; _i5++) {
+                  var _grid$xNeighbour;
+
+                  var yNeighbour = _arr2[_i5];
+                  if (xNeighbour === undefined || yNeighbour === undefined) continue;
+                  if (xNeighbour === _x4 && yNeighbour === _y4) continue;
+                  if (!((_grid$xNeighbour = grid[xNeighbour]) !== null && _grid$xNeighbour !== void 0 && _grid$xNeighbour[yNeighbour])) continue;
+                  pointHandled = true;
+                  grid[_x4][_y4].clusterId = grid[xNeighbour][yNeighbour].clusterId;
+                  break;
+                }
+
+                if (pointHandled) break;
+              }
+
+              clusters[grid[_x4][_y4].clusterId] = (_clusters$grid$_x4$_y = clusters[grid[_x4][_y4].clusterId]) !== null && _clusters$grid$_x4$_y !== void 0 ? _clusters$grid$_x4$_y : [];
+
+              (_clusters$grid$_x4$_y2 = clusters[grid[_x4][_y4].clusterId]).push.apply(_clusters$grid$_x4$_y2, _toConsumableArray(grid[_x4][_y4].members));
+            }
+          } catch (err) {
+            _iterator4.e(err);
+          } finally {
+            _iterator4.f();
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+
+      var clustersInsights = [];
+
+      for (var _clusterId in clusters) {
+        var _hints$axesTitle$hori, _hints$axesTitle$vert3;
+
+        var size = clusters[_clusterId].reduce(function (sum, _ref8) {
+          var value = _ref8.value;
+          return sum + (value !== null && value !== void 0 ? value : 1);
+        }, 0);
+
+        var labels = _toConsumableArray(clusters[_clusterId]).sort(function (a, b) {
+          return b.value - a.value;
+        }).map(function (_ref9) {
+          var label = _ref9.label;
+          return label;
+        }).filter(function (label) {
+          return label !== undefined;
+        });
+
+        var uniqueLabels = _toConsumableArray(new Set(labels));
+
+        var _x3 = clusters[_clusterId].reduce(function (sum, _ref10) {
+          var x = _ref10.x;
+          return sum + x;
+        }, 0) / clusters[_clusterId].length;
+
+        var _y3 = clusters[_clusterId].reduce(function (sum, _ref11) {
+          var y = _ref11.y;
+          return sum + y;
+        }, 0) / clusters[_clusterId].length;
+
+        clustersInsights.push({
+          type: 'cluster',
+          priority: 1,
+          size: size,
+          labels: uniqueLabels,
+          relativeSize: 'average',
+          center: {
+            x: _x3,
+            y: _y3,
+            xLabel: (_hints$axesTitle$hori = hints.axesTitle.horizontal) !== null && _hints$axesTitle$hori !== void 0 ? _hints$axesTitle$hori : guessedXKey,
+            yLabel: (_hints$axesTitle$vert3 = hints.axesTitle.vertical) !== null && _hints$axesTitle$vert3 !== void 0 ? _hints$axesTitle$vert3 : guessedYKey
+          }
+        });
+      }
+
+      entitiesCount = Object.keys(clusters).length;
+      clustersInsights.sort(function (a, b) {
+        return b.size - a.size;
+      });
+      var relativeSizeDistrivution = (_relativeSizeDistrivu = {}, _defineProperty(_relativeSizeDistrivu, 'significantly-bigger', {
+        max: Infinity,
+        min: 0.85
+      }), _defineProperty(_relativeSizeDistrivu, 'bigger', {
+        min: 0.7,
+        max: 0.85
+      }), _defineProperty(_relativeSizeDistrivu, 'slightly-bigger', {
+        min: 0.6,
+        max: 0.7
+      }), _defineProperty(_relativeSizeDistrivu, 'average', {
+        min: 0.4,
+        max: 0.6
+      }), _defineProperty(_relativeSizeDistrivu, 'slightly-smaller', {
+        max: 0.4,
+        min: 0.3
+      }), _defineProperty(_relativeSizeDistrivu, 'smaller', {
+        min: 0.15,
+        max: 0.3
+      }), _defineProperty(_relativeSizeDistrivu, 'significantly-smaller', {
+        min: -Infinity,
+        max: 0.15
+      }), _relativeSizeDistrivu);
+      var averageSize = clustersInsights.reduce(function (sum, cluster) {
+        return sum + cluster.size;
+      }, 0) / clustersInsights.length;
+      var smallerClusters = clustersInsights.filter(function (cluster) {
+        return cluster.size < averageSize;
+      });
+      var smallerSize = smallerClusters.reduce(function (sum, cluster) {
+        return sum + cluster.size;
+      }, 0) / smallerClusters.length;
+      var biggerClusters = clustersInsights.filter(function (cluster) {
+        return cluster.size > averageSize;
+      });
+      var biggerSize = biggerClusters.reduce(function (sum, cluster) {
+        return sum + cluster.size;
+      }, 0) / biggerClusters.length;
+      var normalizingSize = averageSize * 2;
+      var averageSizeNormalized = averageSize / normalizingSize;
+      var smallerSizeNormalized = smallerSize / normalizingSize;
+      var biggerSizeNormalized = biggerSize / normalizingSize;
+      smallerSizeNormalized = !Number.isNaN(smallerSizeNormalized) ? smallerSizeNormalized : 0.25;
+      averageSizeNormalized = !Number.isNaN(averageSizeNormalized) ? averageSizeNormalized : 0.5;
+      biggerSizeNormalized = !Number.isNaN(biggerSizeNormalized) ? biggerSizeNormalized : 0.75;
+      var sizeMapBezier = makeBezier([{
+        x: 0,
+        y: 0
+      }, {
+        x: 0.25,
+        y: smallerSizeNormalized,
+        weight: 10
+      }, {
+        x: 0.5,
+        y: averageSizeNormalized
+      }, {
+        x: 0.75,
+        y: biggerSizeNormalized,
+        weight: 10
+      }, {
+        x: 1,
+        y: 1
+      }], {
+        width: 1,
+        height: 1
+      });
+
+      for (var _i3 = 0, _clustersInsights = clustersInsights; _i3 < _clustersInsights.length; _i3++) {
+        var clustersInsight = _clustersInsights[_i3];
+        var _size = clustersInsight.size;
+        var mappedSize = sizeMapBezier(_size / normalizingSize);
+
+        for (var relativeSize in relativeSizeDistrivution) {
+          var _relativeSizeDistrivu2 = relativeSizeDistrivution[relativeSize],
+              min = _relativeSizeDistrivu2.min,
+              max = _relativeSizeDistrivu2.max;
+
+          if (mappedSize > min && mappedSize <= max) {
+            clustersInsight.relativeSize = relativeSize;
+            break;
+          }
+        }
+      }
+
+      (_insights2 = insights).push.apply(_insights2, clustersInsights);
+
+      if (hints.axesTitle.horizontal) {
+        var sortedX = _toConsumableArray(takenX).sort(function (a, b) {
+          return a - b;
+        });
+
+        dataRange.push({
+          from: sortedX[0],
+          to: sortedX[sortedX.length - 1],
+          label: hints.axesTitle.horizontal
+        });
+      }
+
+      if (hints.axesTitle.vertical) {
+        var sortedY = _toConsumableArray(takenY).sort(function (a, b) {
+          return a - b;
+        });
+
+        dataRange.push({
+          from: sortedY[0],
+          to: sortedY[sortedY.length - 1],
+          label: hints.axesTitle.vertical
+        });
+      }
+    } else if (dataType === 'grouped-values') {
+      var _insights3;
+
+      var makeRowKey = function makeRowKey(row) {
+        return groupKeys.map(function (key, index) {
+          return "".concat(index, "-").concat(getPropByPath(row, key));
+        }).join('-');
+      };
+
+      var allRowsIds = data.map(makeRowKey);
+      var groupedValues = {};
+
+      for (var _i6 = 0; _i6 < data.length; _i6++) {
+        var _groupedValues$key;
+
+        var row = data[_i6];
+        var key = allRowsIds[_i6];
+        groupedValues[key] = (_groupedValues$key = groupedValues[key]) !== null && _groupedValues$key !== void 0 ? _groupedValues$key : {
+          groupName: getPropByPath(row, groupKeys[0]),
+          rows: []
+        };
+        groupedValues[key].rows.push(row);
+      }
+
+      var fields = _toConsumableArray(hints.fields.values);
+
+      var grouppingKeys = Object.fromEntries(groupKeys.map(function (key) {
+        return [key, true];
+      }));
+
+      if (fields.length === 0) {
+        var _fields;
+
+        (_fields = fields).push.apply(_fields, _toConsumableArray(Object.keys(keysMap)));
+      }
+
+      fields = fields.filter(function (key) {
+        return !grouppingKeys[key];
+      });
+      var groups = Object.entries(groupedValues).map(function (_ref12) {
+        var _group$groupName;
+
+        var _ref13 = _slicedToArray(_ref12, 2),
+            groupKey = _ref13[0],
+            group = _ref13[1];
+
+        var values = [];
+
+        var _iterator5 = _createForOfIteratorHelper(group.rows),
+            _step5;
+
+        try {
+          for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+            var _row = _step5.value;
+
+            var _iterator6 = _createForOfIteratorHelper(fields),
+                _step6;
+
+            try {
+              for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+                var _ref15, _hints$titles$getVert, _hints$titles$getVert2, _hints$titles5;
+
+                var field = _step6.value;
+                values.push({
+                  label: (_ref15 = (_hints$titles$getVert = (_hints$titles$getVert2 = (_hints$titles5 = hints.titles).getVerticalAxesTitle) === null || _hints$titles$getVert2 === void 0 ? void 0 : _hints$titles$getVert2.call(_hints$titles5, field)) !== null && _hints$titles$getVert !== void 0 ? _hints$titles$getVert : hints.titles.valuesAxes[field]) !== null && _ref15 !== void 0 ? _ref15 : field,
+                  value: getPropByPath(_row, field)
+                });
+              }
+            } catch (err) {
+              _iterator6.e(err);
+            } finally {
+              _iterator6.f();
+            }
+          }
+        } catch (err) {
+          _iterator5.e(err);
+        } finally {
+          _iterator5.f();
+        }
+
+        values.sort(function (a, b) {
+          if (typeof a.value !== 'number' || typeof b.value !== 'number') return 0;
+          return b.value - a.value;
+        });
+        var averageValue = values.reduce(function (sum, _ref14) {
+          var value = _ref14.value;
+          return sum + value;
+        }, 0) / values.length;
+        return {
+          label: (_group$groupName = group.groupName) !== null && _group$groupName !== void 0 ? _group$groupName : groupKey,
+          values: values,
+          averageValue: !Number.isNaN(averageValue) ? averageValue : undefined
+        };
+      });
+      groups.sort(function (a, b) {
+        if (typeof a.averageValue !== 'number' || typeof b.averageValue !== 'number') return 0;
+        return b.averageValue - a.averageValue;
+      });
+      entitiesCount = groups.length;
+
+      (_insights3 = insights).push.apply(_insights3, _toConsumableArray(groups.map(function (group) {
+        return {
+          type: 'comparison',
+          label: group.label,
+          values: group.values,
+          priority: 1
+        };
+      })));
+    }
+  }
+
+  if (dataType === 'values-set') {
+    var _fields2 = _toConsumableArray(hints.fields.values);
+
+    if (_fields2.length === 0) {
+      _fields2.push.apply(_fields2, _toConsumableArray(Object.keys(keysMap)));
+    }
+
+    var values = _fields2.map(function (field) {
+      var _ref16, _hints$titles$getValu, _hints$titles$getValu2, _hints$titles6;
+
+      return {
+        label: (_ref16 = (_hints$titles$getValu = (_hints$titles$getValu2 = (_hints$titles6 = hints.titles).getValueAxesTitle) === null || _hints$titles$getValu2 === void 0 ? void 0 : _hints$titles$getValu2.call(_hints$titles6, field)) !== null && _hints$titles$getValu !== void 0 ? _hints$titles$getValu : hints.titles.valuesAxes[field]) !== null && _ref16 !== void 0 ? _ref16 : field,
+        value: getPropByPath(data, field)
+      };
+    });
+
+    entitiesCount = values.length;
+    values.sort(function (a, b) {
+      if (typeof a.value !== 'number' || typeof b.value !== 'number') return 0;
+      return b.value - a.value;
+    });
+    insights.push({
+      type: 'comparison',
+      values: values,
+      priority: 1
+    });
+  }
+
+  var hasHighPriorityInsights = insights.some(function (insight) {
+    return insight.priority > 0;
+  });
+
+  if (hasHighPriorityInsights) {
+    insights = insights.filter(function (insight) {
+      return insight.priority > 0;
+    });
+  } else {
+    insights = insights.slice(0, 1);
+  }
+
+  return {
+    insights: insights,
+    dataType: dataType,
+    dataRange: dataRange,
+    dataTitle: dataTitle,
+    entitiesCount: entitiesCount
+  };
+};
+//# sourceMappingURL=insights.js.map