@hestia-earth/ui-components-charts 0.43.23

package/dist/index.js

@@ -0,0 +1,834 @@
+'use strict';
+
+var utils = require('@hestia-earth/utils');
+var Gradient = require('javascript-color-gradient');
+var shadeGenerator = require('shade-generator/dist/shadeGenerator');
+var emissionGroupings = require('@hestia-earth/glossary/resources/emission-groupings.json');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Gradient__default = /*#__PURE__*/_interopDefault(Gradient);
+var emissionGroupings__default = /*#__PURE__*/_interopDefault(emissionGroupings);
+
+// src/charts/bar.ts
+
+// src/charts/constants.ts
+var defaultTicksFont = {
+  family: "Lato",
+  size: 13
+};
+var chartLabelMaxLength = 50;
+
+// src/charts/bar.ts
+var grey = "#4a4a4a";
+var defaultBarSettings = Object.freeze({
+  type: "bar",
+  options: {
+    animation: {
+      duration: 0
+    },
+    plugins: {
+      legend: {
+        align: "start"
+      },
+      tooltip: {
+        enabled: false
+      }
+    },
+    scales: {
+      x: {
+        display: true,
+        min: 0,
+        title: {
+          display: false,
+          color: grey,
+          font: defaultTicksFont
+        },
+        ticks: {
+          font: defaultTicksFont
+        }
+      },
+      y: {
+        display: true,
+        position: "left",
+        border: {
+          display: true
+        },
+        grid: {
+          display: true,
+          drawOnChartArea: true,
+          drawTicks: true,
+          tickLength: 8,
+          offset: false
+        },
+        ticks: {
+          color: grey,
+          padding: 4,
+          crossAlign: "center",
+          font: {
+            ...defaultTicksFont,
+            weight: 400
+          },
+          callback: function(value) {
+            const label = this.getLabelForValue(value);
+            return utils.ellipsis(label, chartLabelMaxLength);
+          }
+        }
+      }
+    }
+  }
+});
+var defaultBarDatasets = {
+  barThickness: 2,
+  barPercentage: 1,
+  categoryPercentage: 1
+};
+var withOthers = (data2, maximum) => {
+  const included = data2.slice(0, maximum);
+  const excluded = data2.slice(maximum);
+  return excluded.length ? [
+    ...included,
+    {
+      label: `${excluded.length} others`,
+      count: utils.sum(excluded.map(({ count }) => count)),
+      backgroundColor: excluded[0].backgroundColor,
+      borderColor: excluded[0].borderColor,
+      color: excluded[0].color,
+      includedItems: excluded
+    }
+  ] : included;
+};
+var hasNegativeContributions = (data2 = []) => data2.some(({ count }) => count < 0);
+var barDataset = (data2, label = "", showNegativeValues = true) => ({
+  ...defaultBarDatasets,
+  backgroundColor: data2.map(({ backgroundColor, color }) => backgroundColor || color),
+  borderColor: data2.map(({ borderColor, color }) => borderColor || color),
+  data: data2.map(({ count }) => utils.toPrecision(showNegativeValues ? count : Math.max(0, count))),
+  label
+});
+var ColorPalette = /* @__PURE__ */ ((ColorPalette2) => {
+  ColorPalette2[ColorPalette2["categorial"] = 0] = "categorial";
+  ColorPalette2[ColorPalette2["continuous"] = 1] = "continuous";
+  ColorPalette2[ColorPalette2["divergent"] = 2] = "divergent";
+  return ColorPalette2;
+})(ColorPalette || {});
+var palette = Object.freeze({
+  [0 /* categorial */]: [
+    "#193957",
+    "#FFC000",
+    "#249DA5",
+    "#DC7033",
+    "#349B3E",
+    "#CCA76D",
+    "#6394CE",
+    "#9AB04C",
+    "#8B50A7",
+    "#8A5402"
+  ],
+  [1 /* continuous */]: [
+    "#193957",
+    "#1D586F",
+    "#207788",
+    "#498F78",
+    "#7FA55B",
+    "#B0B43B",
+    "#DDBB19",
+    "#FFC514",
+    "#FDD866",
+    "#FCEBB8"
+  ],
+  [2 /* divergent */]: [
+    "#193957",
+    "#1D6176",
+    "#228A96",
+    "#58B3B5",
+    "#ACD6CF",
+    "#FCEBB8",
+    "#FCE18F",
+    "#FDD763",
+    "#FECC34",
+    "#FFC000"
+  ]
+});
+var getGradients = (...colours) => new Gradient__default.default().setColorGradient(...colours).setMidpoint(10).getColors();
+var getColorGradient = (index, colors) => {
+  const start = colors[index % colors.length];
+  const end = colors[index % colors.length + 1];
+  const gradientIndex = Math.ceil(index / colors.length);
+  return getGradients(start, end)[gradientIndex];
+};
+var getColorShade = (index, colors) => {
+  const color = colors[index % colors.length];
+  const shade = Math.min(100, Math.max(10, Math.abs(100 - Math.ceil(index / colors.length) * 10)));
+  return shadeGenerator.ShadeGenerator.hue(color).shade(`${shade}`).hex();
+};
+var getColor = (index, scheme = 0 /* categorial */) => {
+  const colors = palette[scheme];
+  return index < colors.length ? colors[index] : scheme === 0 /* categorial */ ? getColorShade(index, colors) : getColorGradient(index, colors);
+};
+var listColor = (_v, index) => getColor(index);
+var listColorContinuous = (_v, index) => getColor(index, 1 /* continuous */);
+var parseColor = (color) => {
+  let r = 75, g = 192, b = 192;
+  if (color) {
+    if (color.startsWith("#")) {
+      const hex = color.replace("#", "");
+      r = parseInt(hex.substring(0, 2), 16);
+      g = parseInt(hex.substring(2, 4), 16);
+      b = parseInt(hex.substring(4, 6), 16);
+    } else if (color.startsWith("rgb")) {
+      const matches = color.match(/\d+/g);
+      if (matches) {
+        r = parseInt(matches[0]);
+        g = parseInt(matches[1]);
+        b = parseInt(matches[2]);
+      }
+    }
+  }
+  return { r, g, b };
+};
+var colorToRgba = (color, aplha) => `rgba(${color.r}, ${color.g}, ${color.b}, ${aplha})`;
+var hexToRgba = (hex, aplha = 1) => {
+  const color = parseColor(hex);
+  return color ? `rgba(${color.r}, ${color.g}, ${color.b}, ${aplha})` : hex;
+};
+var listColorWithAlpha = (alpha = 0.8) => (_v, index) => hexToRgba(getColor(index), alpha);
+var sumValues = (values) => {
+  const definedValues = values.filter((value) => !utils.isUndefined(value));
+  return definedValues.length ? utils.sum(definedValues) : void 0;
+};
+var groupByCategory = (data2, category, emissionCategoryValue2) => data2.reduce(
+  (prev, curr) => {
+    const groupKey = emissionCategoryValue2(curr.id, category);
+    prev[groupKey] = prev[groupKey] || [];
+    prev[groupKey].push(curr);
+    return prev;
+  },
+  {}
+);
+var groupDataByCategory = (data2, labels, category, { emissionCategoryValue: emissionCategoryValue2, categoryLabel: categoryLabel2 }) => {
+  if (!category) {
+    return data2;
+  }
+  const groupedData = groupByCategory(data2, category, emissionCategoryValue2);
+  return Object.keys(groupedData).length === 1 ? data2 : Object.entries(groupedData).map(([groupKey, items], index) => ({
+    label: categoryLabel2(groupKey),
+    values: labels.map((_, i) => sumValues(items.map((item) => item.values[i]))),
+    color: listColor(groupKey, index),
+    includedItems: items.map((item, i) => ({
+      ...item,
+      color: listColor(item.id, i)
+    }))
+  }));
+};
+
+// src/charts/csv.ts
+var escape = (value) => `${value}`.includes(",") ? `"${value}"` : value;
+var toLine = (values) => values.map(escape).join(",");
+var data = emissionGroupings__default.default;
+var categoryLabel = (key) => key ? utils.keyToLabel(key.replace(/category/gi, "")) : "Unset";
+var emissionCategories = Object.keys(data).filter((key) => key.toLowerCase().endsWith("category")).map((key) => ({ key, label: categoryLabel(key) }));
+var categoryValues = (category) => data[category];
+var emissionCategoriesOf = (emissionId) => Object.keys(data[emissionId]).filter((key) => !!data[emissionId][key]);
+var emissionCategoryValue = (emissionId, category) => {
+  var _a;
+  return (_a = data[emissionId]) == null ? void 0 : _a[category];
+};
+var defaultHorizontalBarConfig = Object.freeze({
+  options: {
+    indexAxis: "y",
+    scales: {
+      x: {
+        grid: {
+          drawOnChartArea: false
+        },
+        ticks: {
+          callback: (value) => utils.toPrecision(Number(value), 3)
+        }
+      },
+      y: {
+        grid: {
+          drawOnChartArea: false
+        },
+        ticks: {
+          crossAlign: "near"
+        }
+      }
+    }
+  }
+});
+var defaultHorizontalTooltip = ({ label, count, includedItems }) => (includedItems == null ? void 0 : includedItems.length) ? includedItems.map(defaultHorizontalTooltip).join("</br>") : `${label}: ${count}`;
+var rowHeight = 40;
+var padding = 60;
+var horizontalBarHeight = (minHeight, maxHeight, nbRows) => Math.min(Math.max(nbRows * rowHeight + padding, minHeight), maxHeight);
+var placementGap = (placement) => placement === "right" ? 8 : -8;
+var placementX = (x, chart, data2, placement) => placement === "right" ? !Array.isArray(data2) && data2 < 0 ? positionAtZero(chart) : x : x;
+var positionAtZero = (chart) => chart.scales.x.getPixelForValue(0);
+var defaultBarDrawSettings = {
+  placement: "right",
+  xPosFn: (x, index, width, chart, data2, placement) => (utils.isEmpty(data2) ? positionAtZero(chart) : placementX(x, chart, data2, placement)) + placementGap(placement),
+  yPosFn: (y) => y + 3,
+  colorFn: (m, index, chart, data2) => utils.isUndefined(data2) ? "#b5b5b5" : "#4a4a4a",
+  textFn: ({ data: data2 }) => `${data2}`,
+  font: `${defaultTicksFont.size}px ${defaultTicksFont.family}`,
+  maxWidth: 90,
+  emptyValueLabel: "No data"
+};
+var drawText = (ctx, {
+  text,
+  font,
+  fillStyle,
+  placement,
+  xPos,
+  yPos,
+  maxWidth
+}) => {
+  ctx.font = font;
+  ctx.fillStyle = fillStyle;
+  ctx.textAlign = placement === "left" ? "right" : "left";
+  if (Array.isArray(text)) {
+    ctx.fillText(text[0], xPos, yPos - 5, maxWidth);
+    ctx.fillText(text[1], xPos, yPos + 5, maxWidth);
+  } else {
+    ctx.fillText(text, xPos, yPos, maxWidth);
+  }
+};
+var calculateNextData = (currentData, newData, hasExistingData) => utils.isUndefined(newData) ? currentData : hasExistingData ? typeof newData === "number" && typeof currentData === "number" ? currentData + newData : newData : newData;
+var afterBarDrawPlugin = (settings) => ({
+  id: ["afterBarDrawPlugin", settings == null ? void 0 : settings.placement].filter(Boolean).join("-"),
+  afterDatasetsDraw: (chart) => {
+    var _a, _b;
+    if (!((_a = chart.data.datasets) == null ? void 0 : _a.length) || !((_b = chart.data.labels) == null ? void 0 : _b.length)) {
+      return;
+    }
+    const { placement, xPosFn, yPosFn, colorFn, textFn, maxWidth, font, emptyValueLabel } = {
+      ...defaultBarDrawSettings,
+      ...settings != null ? settings : {}
+    };
+    const { ctx, width, height } = chart;
+    ctx.save();
+    const getStackItems = (index) => chart.data.datasets.map((dataset, dsIndex) => ({ dataset, meta: chart.getDatasetMeta(dsIndex) })).filter(({ meta }) => !meta.hidden).map(({ dataset, meta }) => ({
+      element: meta.data[index],
+      dataVal: dataset.data[index]
+    })).filter(({ element }) => element && !element.skip);
+    const aggregateStackItems = (stackItems) => stackItems.reduce(
+      (acc, { element, dataVal }) => ({
+        finalData: calculateNextData(acc.finalData, dataVal, acc.hasData),
+        hasData: acc.hasData || !utils.isUndefined(dataVal),
+        minX: Math.min(acc.minX, element.base, element.x),
+        maxX: Math.max(acc.maxX, element.base, element.x),
+        lastVisibleElement: element
+      }),
+      {
+        finalData: void 0,
+        hasData: false,
+        minX: Infinity,
+        maxX: -Infinity,
+        lastVisibleElement: stackItems[0].element
+      }
+    );
+    const getLabel = (index) => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = chart.data.labels) == null ? void 0 : _a2[index]) != null ? _b2 : "";
+    };
+    const getXPos = (anchorX, index, dataToPass) => xPosFn(anchorX, index, width, chart, dataToPass, placement);
+    const getYPos = (y, index, dataToPass) => yPosFn(y, index, height, chart, dataToPass, placement);
+    const getAnchorX = (minX, maxX) => placement === "left" ? minX : maxX;
+    const processIndex = (index) => {
+      const stackItems = getStackItems(index);
+      if (!stackItems.length) {
+        return;
+      }
+      const { finalData, hasData, minX, maxX, lastVisibleElement } = aggregateStackItems(stackItems);
+      const dataToPass = hasData ? finalData : void 0;
+      const text = !hasData ? emptyValueLabel : textFn({ label: getLabel(index), data: dataToPass }, index, chart);
+      if (text) {
+        drawText(ctx, {
+          text,
+          font,
+          fillStyle: colorFn(lastVisibleElement.options, index, chart, dataToPass),
+          placement,
+          xPos: getXPos(getAnchorX(minX, maxX), index, dataToPass),
+          yPos: getYPos(lastVisibleElement.y, index, dataToPass),
+          maxWidth
+        });
+      }
+    };
+    const indices = Array.from({ length: chart.data.labels.length }, (_, i) => i);
+    indices.forEach(processIndex);
+    ctx.restore();
+  }
+});
+
+// src/charts/plugins/axisHover.plugin.ts
+var axisLabelCursor = ({ label, event }) => {
+  var _a;
+  const canvas = (_a = event == null ? void 0 : event.native) == null ? void 0 : _a.target;
+  if (label && canvas) {
+    canvas.style.cursor = "pointer";
+  }
+};
+var axisSettings = (chart) => {
+  var _a;
+  return ((_a = chart.config.options.plugins) == null ? void 0 : _a.axisHover) || {};
+};
+var disabled = (chart, { onHoverLabel, onClickLabel }) => !chart.scales.y || !onHoverLabel && !onClickLabel;
+var isOverAxis = (scale, event) => event.x != null && event.x >= scale.left && event.x <= scale.right;
+var tickAt = (scale, y, maxDistance) => {
+  const ticks = scale.getTicks();
+  const position = ticks.findIndex((_, index) => Math.abs(y - scale.getPixelForTick(index)) < maxDistance);
+  return position < 0 ? null : { index: ticks[position].value, y: scale.getPixelForTick(position) };
+};
+var labelAt = (chart, index) => index >= 0 ? chart.data.labels[index] : "";
+var labelEvent = (chart, event, maxDistance) => {
+  const scale = chart.scales.y;
+  const tick = isOverAxis(scale, event) ? tickAt(scale, event.y, maxDistance) : null;
+  const index = tick ? tick.index : -1;
+  return {
+    label: labelAt(chart, index),
+    index,
+    anchorX: (scale.left + scale.right) / 2,
+    anchorY: (tick ? tick.y : event.y) + maxDistance,
+    event
+  };
+};
+var notifyClick = ({ onClickLabel }, data2) => data2.index >= 0 && data2.event.type === "click" ? onClickLabel == null ? void 0 : onClickLabel(data2) : void 0;
+var axisHoverPlugin = {
+  id: "axisHover",
+  afterEvent(chart, { event }) {
+    var _a, _b;
+    const settings = axisSettings(chart);
+    if (disabled(chart, settings)) return;
+    const data2 = labelEvent(chart, event, (_a = settings.maxDistance) != null ? _a : 15);
+    (_b = settings.onHoverLabel) == null ? void 0 : _b.call(settings, data2);
+    notifyClick(settings, data2);
+  }
+};
+
+// src/charts/plugins/background-hover.plugin.ts
+var createHoverGradient = (ctx, chartArea, color) => {
+  const gradient = ctx.createLinearGradient(chartArea.left, 0, chartArea.right, 0);
+  gradient.addColorStop(0, colorToRgba(color, 0.05));
+  gradient.addColorStop(0.5, colorToRgba(color, 0.12));
+  gradient.addColorStop(1, colorToRgba(color, 0.05));
+  return gradient;
+};
+var calculateBarBounds = (element, indexAxis = "y") => {
+  const { x, y, base, width, height } = element;
+  if (indexAxis === "y") {
+    const barHeight = height;
+    const barTop = y - barHeight / 2;
+    const barBottom = y + barHeight / 2;
+    const barLeft = Math.min(base, x);
+    const barRight = Math.max(base, x);
+    return { barLeft, barRight, barTop, barBottom, thickness: barHeight };
+  } else {
+    const barWidth = width;
+    const barLeft = x - barWidth / 2;
+    const barRight = x + barWidth / 2;
+    const barTop = Math.min(base, y);
+    const barBottom = Math.max(base, y);
+    return { barLeft, barRight, barTop, barBottom, thickness: barWidth };
+  }
+};
+var calculateShadowBounds = (element, bounds, threshold) => {
+  return {
+    top: bounds.barTop - threshold,
+    bottom: bounds.barBottom + threshold,
+    left: bounds.barLeft,
+    // Usually we expand Y (thickness), but keep X (length) capped at value
+    right: bounds.barRight,
+    width: bounds.barRight - bounds.barLeft,
+    height: bounds.barBottom + threshold - (bounds.barTop - threshold)
+  };
+};
+var drawHoverEffect = (ctx, chartArea, element, threshold, indexAxis) => {
+  const opts = element.options || null;
+  const barColor = (opts == null ? void 0 : opts.backgroundColor) || (opts == null ? void 0 : opts.borderColor) || "#000000";
+  if (barColor.length !== 7) {
+    return;
+  }
+  const color = parseColor(barColor);
+  const bounds = calculateBarBounds(element, indexAxis);
+  const shadow = calculateShadowBounds(element, bounds, threshold);
+  ctx.save();
+  const gradient = createHoverGradient(ctx, { left: shadow.left, right: shadow.right }, color);
+  ctx.fillStyle = gradient;
+  ctx.fillRect(shadow.left, shadow.top, shadow.width, shadow.height);
+  drawHorizontalLines(ctx, { left: shadow.left, right: shadow.right }, shadow.top, shadow.bottom, color);
+  ctx.restore();
+};
+var drawHorizontalLines = (ctx, barArea, topY, bottomY, color) => {
+  ctx.strokeStyle = colorToRgba(color, 0.25);
+  ctx.lineWidth = 1;
+  ctx.setLineDash([5, 5]);
+  ctx.beginPath();
+  ctx.moveTo(barArea.left, topY);
+  ctx.lineTo(barArea.right, topY);
+  ctx.moveTo(barArea.left, bottomY);
+  ctx.lineTo(barArea.right, bottomY);
+  ctx.stroke();
+};
+var calculateDistanceToBar = (x, y, bounds) => {
+  let distance = 0;
+  if (x < bounds.barLeft) distance += Math.pow(bounds.barLeft - x, 2);
+  else if (x > bounds.barRight) distance += Math.pow(x - bounds.barRight, 2);
+  if (y < bounds.barTop) distance += Math.pow(bounds.barTop - y, 2);
+  else if (y > bounds.barBottom) distance += Math.pow(y - bounds.barBottom, 2);
+  return Math.sqrt(distance);
+};
+var isWithinHitArea = (x, y, bounds, threshold) => {
+  const hitLeft = bounds.barLeft - threshold;
+  const hitRight = bounds.barRight + threshold;
+  const hitTop = bounds.barTop - threshold;
+  const hitBottom = bounds.barBottom + threshold;
+  return x >= hitLeft && x <= hitRight && y >= hitTop && y <= hitBottom;
+};
+var checkBarProximity = (element, index, datasetIndex, x, y, threshold, currentClosest, indexAxis) => {
+  const bar2 = element;
+  if (bar2.x == null || bar2.y == null) return;
+  const bounds = calculateBarBounds(bar2, indexAxis);
+  if (!isWithinHitArea(x, y, bounds, threshold)) return;
+  const distance = calculateDistanceToBar(x, y, bounds);
+  if (distance < currentClosest.distance) {
+    currentClosest.distance = distance;
+    currentClosest.bar = {
+      datasetIndex,
+      index,
+      element: bar2
+      // Save the whole element
+    };
+  }
+};
+var findNearBar = (chart, x, y, threshold) => {
+  var _a;
+  const closest = { bar: null, distance: Infinity };
+  const indexAxis = chart.options.indexAxis || "x";
+  (_a = chart.data.datasets) == null ? void 0 : _a.forEach((dataset, datasetIndex) => {
+    if (!chart.isDatasetVisible(datasetIndex)) return;
+    const meta = chart.getDatasetMeta(datasetIndex);
+    meta.data.forEach((element, index) => {
+      if (element.hidden || element.skip) return;
+      checkBarProximity(element, index, datasetIndex, x, y, threshold, closest, indexAxis);
+    });
+  });
+  return closest.distance <= threshold ? closest.bar : void 0;
+};
+var triggerBarClick = (chart, barData) => {
+  var _a;
+  const activeElements = [
+    {
+      element: barData.element,
+      datasetIndex: barData.datasetIndex,
+      index: barData.index
+    }
+  ];
+  chart.setActiveElements(activeElements);
+  (_a = chart.tooltip) == null ? void 0 : _a.setActiveElements(activeElements, { x: 0, y: 0 });
+  const onClickHandler = chart.options.onClick;
+  if (onClickHandler) {
+    const mockEvent = {
+      type: "click",
+      x: barData.element.x,
+      y: barData.element.y,
+      chart,
+      native: {
+        target: chart.canvas,
+        preventDefault: () => {
+        },
+        stopPropagation: () => {
+        }
+      }
+    };
+    onClickHandler.call(chart, mockEvent, activeElements, chart);
+  }
+  chart.update();
+};
+var handleMouseMove = (chart, nearBar, threshold, e) => {
+  const newNearBar = findNearBar(chart, e.x, e.y, threshold);
+  const prevCursor = chart.canvas.style.cursor;
+  const newCursor = newNearBar ? "pointer" : "default";
+  if (prevCursor !== newCursor) {
+    chart.canvas.style.cursor = newCursor;
+  }
+  const hasChanged = (newNearBar == null ? void 0 : newNearBar.datasetIndex) !== (nearBar == null ? void 0 : nearBar.datasetIndex) || (newNearBar == null ? void 0 : newNearBar.index) !== (nearBar == null ? void 0 : nearBar.index);
+  return {
+    nearBar: hasChanged ? newNearBar || null : nearBar,
+    changed: hasChanged
+  };
+};
+var handleMouseOut = (chart, nearBar) => {
+  chart.canvas.style.cursor = "default";
+  return !!nearBar;
+};
+var handleClick = (chart, nearBar) => {
+  if (nearBar) triggerBarClick(chart, nearBar);
+};
+var getActiveBar = (chart) => {
+  var _a, _b;
+  const activeElements = (_a = chart.tooltip) == null ? void 0 : _a.getActiveElements();
+  return (_b = activeElements == null ? void 0 : activeElements[0]) == null ? void 0 : _b.element;
+};
+var defaultSettings = { threshold: 10 };
+var backgroundHoverPlugin = (settings = {}) => {
+  let nearBar = null;
+  const { threshold } = { ...defaultSettings, ...settings };
+  return {
+    id: "backgroundHover",
+    afterEvent: (chart, args) => {
+      const e = args.event;
+      let changed = false;
+      if (e.type === "mousemove") {
+        const result = handleMouseMove(chart, nearBar, threshold || 10, e);
+        nearBar = result.nearBar;
+        changed = result.changed;
+      } else if (e.type === "mouseout") {
+        changed = handleMouseOut(chart, nearBar);
+        nearBar = null;
+      } else if (e.type === "click") {
+        handleClick(chart, nearBar);
+      }
+      args.changed = changed;
+    },
+    beforeDraw: (chart) => {
+      const indexAxis = chart.options.indexAxis || "x";
+      const activeBar = nearBar ? nearBar.element : getActiveBar(chart);
+      activeBar && drawHoverEffect(chart.ctx, chart.chartArea, activeBar, threshold || 10, indexAxis);
+    }
+  };
+};
+var isMouseInsideCircle = (event, circleCenter, circleRadius) => {
+  const { clientX, clientY } = event;
+  const circleX = circleCenter.x;
+  const circleY = circleCenter.y;
+  const distance = Math.sqrt((clientX - circleX) ** 2 + (clientY - circleY) ** 2);
+  return distance <= circleRadius;
+};
+var circle = (ctx, x, y, color, radius) => {
+  ctx.beginPath();
+  ctx.arc(x, y, radius, 0, Math.PI * 2);
+  ctx.fillStyle = color;
+  ctx.fill();
+};
+var line = (ctx, startX, endX, y, color, lineWidth) => {
+  ctx.beginPath();
+  ctx.lineWidth = lineWidth;
+  ctx.strokeStyle = color;
+  ctx.moveTo(startX, y);
+  ctx.lineTo(endX, y);
+  ctx.stroke();
+};
+var defaultLollipopSettings = {
+  circleRadius: 4,
+  colorFn: (m) => m.backgroundColor,
+  isMouseInsideLollipopFn: () => null
+};
+var lollipopChartPlugin = (settings) => ({
+  id: "lollipopChartPlugin",
+  afterDatasetsDraw: (chart) => {
+    var _a;
+    if (!((_a = chart.data.datasets) == null ? void 0 : _a.length)) {
+      return;
+    }
+    const { circleRadius, lineWidth, colorFn, isMouseInsideLollipopFn, valueFn } = {
+      ...defaultLollipopSettings,
+      ...settings != null ? settings : {}
+    };
+    const { ctx } = chart;
+    ctx.save();
+    const clickableDictionary = [];
+    chart.data.datasets.forEach((dataset, datasetIndex) => {
+      const meta = chart.getDatasetMeta(datasetIndex);
+      if (meta.hidden) return;
+      ctx.save();
+      const elements = meta.data;
+      elements.filter((element) => !element.skip).forEach((element, index) => {
+        const { base, x, y } = element;
+        const color = colorFn(element.options, index);
+        const data2 = dataset.data[index];
+        const overrideValue = valueFn == null ? void 0 : valueFn(dataset, index, chart);
+        const xValue = utils.isUndefined(overrideValue) ? x : chart.scales.x.getPixelForValue(overrideValue);
+        clickableDictionary.push(
+          (clientX, clientY) => isMouseInsideCircle({ clientX, clientY }, { x: xValue, y }, circleRadius)
+        );
+        circle(ctx, xValue, y, color, circleRadius);
+        [Array.isArray(data2), !!lineWidth].every(Boolean) && line(ctx, base, x, y, color, lineWidth);
+        if (utils.isUndefined(overrideValue)) {
+          clickableDictionary.push(
+            (clientX, clientY) => isMouseInsideCircle({ clientX, clientY }, { x: base, y }, circleRadius)
+          );
+          Array.isArray(data2) && circle(ctx, base, y, color, circleRadius);
+        }
+      });
+      ctx.restore();
+    });
+    isMouseInsideLollipopFn((x, y) => clickableDictionary.findIndex((fn) => fn(x, y)));
+  }
+});
+
+// src/charts/plugins/index.ts
+var increaseScaleLimits = (scale, handleMinScaleZero = true) => {
+  const range = scale.max - scale.min;
+  const safeRange = range === 0 ? Math.abs(scale.max) || 1 : range;
+  const margin = 0.1;
+  const padding2 = safeRange * margin;
+  scale.min -= handleMinScaleZero && scale.min === 0 ? 0 : padding2;
+  scale.max += padding2;
+};
+
+// src/charts/indicator-breakdown.ts
+var logsTotalValue = (logs, includeNegativeValues = true) => utils.sum((includeNegativeValues ? logs : logs.filter((curr) => curr.value >= 0)).map((v) => v.value));
+var valueRatio = (value, total) => total === 0 ? 0 : utils.toPrecision(value * 100 / Math.abs(total), 2);
+var chartLabel = (value, total) => {
+  const ratio = total === 0 ? 0 : value * 100 / Math.abs(total);
+  return value === 0 ? "0" : `${value}, ${utils.toPrecision(ratio, 2)}%`;
+};
+var chartBreakdownLabel = (logs, total, maxValues) => logs.slice(maxValues).map(({ blankNodeTermId, value }) => `${blankNodeTermId}: ${chartLabel(value, total)}`).join("</br>");
+var logToCsv = (logs, impact) => [
+  toLine(["Impact", "Impact Unit", "Method", "Emission", "Value", "Inputs", "Functional Unit"]),
+  ...[...logs].sort((a, b) => a.impactTermId.localeCompare(b.impactTermId)).map(
+    ({ impactTermId, impactTermUnits, modelId, blankNodeTermId, value, inputs }) => {
+      var _a, _b;
+      return toLine([
+        impactTermId,
+        impactTermUnits,
+        modelId,
+        blankNodeTermId,
+        value,
+        inputs.join(";"),
+        (_b = (_a = impact.product) == null ? void 0 : _a.term) == null ? void 0 : _b.units
+      ]);
+    }
+  )
+].join("\n");
+var processContributions = (record, nodes, impacts) => Object.entries(record || {}).flatMap(([index, impactContr]) => {
+  const indicator = nodes[+index];
+  return indicator ? Object.entries(impactContr).flatMap(([impactTermId, modelContr]) => {
+    const impact = impacts == null ? void 0 : impacts.find((v) => v.term["@id"] === impactTermId);
+    return impact && Object.entries(modelContr).map(
+      ([modelId, value]) => {
+        var _a;
+        return {
+          modelId,
+          impactTermId,
+          impactTermUnits: (_a = impact.term) == null ? void 0 : _a.units,
+          blankNodeTermId: indicator.term["@id"],
+          value: utils.toPrecision(value, 3),
+          inputs: (indicator.inputs || []).map((v) => v["@id"])
+        };
+      }
+    );
+  }) : null;
+});
+var parseContributions = (impactAssessment, contributions) => [
+  ...processContributions(
+    contributions == null ? void 0 : contributions.emissionsResourceUse,
+    impactAssessment.emissionsResourceUse || [],
+    (impactAssessment == null ? void 0 : impactAssessment.impacts) || []
+  ),
+  ...processContributions(contributions == null ? void 0 : contributions.impacts, impactAssessment.impacts || [], (impactAssessment == null ? void 0 : impactAssessment.endpoints) || [])
+].filter(Boolean);
+var groupLogsById = (logs) => Object.values(
+  logs.reduce(
+    (prev, log) => {
+      const key = log.blankNodeTermId;
+      prev[key] = prev[key] || { ...log, value: 0 };
+      prev[key].value += log.value;
+      prev[key].inputs = utils.unique([...prev[key].inputs, ...log.inputs || []]);
+      return prev;
+    },
+    {}
+  )
+);
+var indicatorLogs = (logs, termId, methodId) => logs.filter(({ impactTermId, modelId }) => impactTermId === termId && (!methodId || modelId === methodId));
+var nonZeroContributors = (logs) => groupLogsById(logs).filter((log) => log.value !== 0);
+var namedContributors = (logs, nameOf) => logs.map((value, index) => ({
+  ...value,
+  name: nameOf(value.blankNodeTermId) || value.blankNodeTermId,
+  color: listColor(value, index)
+}));
+var bar = ({ name, value, color }) => ({
+  label: name,
+  count: value,
+  backgroundColor: color
+});
+var breakdownBars = (values, category) => {
+  const groups = values.reduce(
+    (prev, curr) => {
+      const key = category ? emissionCategoryValue(curr.blankNodeTermId, category) : void 0;
+      return { ...prev, [key]: [...prev[key] || [], curr] };
+    },
+    {}
+  );
+  const bars = Object.keys(groups).length === 1 ? values.map(bar) : Object.entries(groups).map(([key, items]) => ({
+    label: categoryLabel(key),
+    count: logsTotalValue(items, true),
+    backgroundColor: items[0].color,
+    includedItems: items.map(bar)
+  }));
+  return bars.sort((a, b) => Math.abs(b.count) - Math.abs(a.count));
+};
+var breakdownBarText = (displayValue, total, maximumValues) => displayValue ? { textFn: ({ label, data: data2 }, index) => index === maximumValues ? `${label} at ${data2}` : `${data2}` } : { textFn: ({ data: data2 }) => `${valueRatio(data2, total)}%` };
+var breakdownTooltip = (item, includedItems, logs, total, maximumValues) => !utils.isUndefined(item == null ? void 0 : item.count) ? (includedItems == null ? void 0 : includedItems.length) ? chartBreakdownLabel(logs, total, maximumValues) : `${item.label}: ${chartLabel(item.count, total)}` : "";
+var breakdownScale = (values) => {
+  const numbers = values.map((v) => v.value);
+  return {
+    options: {
+      scales: {
+        x: {
+          afterDataLimits: (scale) => increaseScaleLimits(scale),
+          min: numbers.some((v) => v < 0) ? Math.min(...numbers) : 0,
+          max: Math.max(...numbers)
+        }
+      }
+    }
+  };
+};
+
+exports.ColorPalette = ColorPalette;
+exports.afterBarDrawPlugin = afterBarDrawPlugin;
+exports.axisHoverPlugin = axisHoverPlugin;
+exports.axisLabelCursor = axisLabelCursor;
+exports.backgroundHoverPlugin = backgroundHoverPlugin;
+exports.barDataset = barDataset;
+exports.breakdownBarText = breakdownBarText;
+exports.breakdownBars = breakdownBars;
+exports.breakdownScale = breakdownScale;
+exports.breakdownTooltip = breakdownTooltip;
+exports.categoryLabel = categoryLabel;
+exports.categoryValues = categoryValues;
+exports.chartBreakdownLabel = chartBreakdownLabel;
+exports.chartLabel = chartLabel;
+exports.chartLabelMaxLength = chartLabelMaxLength;
+exports.colorToRgba = colorToRgba;
+exports.defaultBarDatasets = defaultBarDatasets;
+exports.defaultBarSettings = defaultBarSettings;
+exports.defaultHorizontalBarConfig = defaultHorizontalBarConfig;
+exports.defaultHorizontalTooltip = defaultHorizontalTooltip;
+exports.defaultTicksFont = defaultTicksFont;
+exports.emissionCategories = emissionCategories;
+exports.emissionCategoriesOf = emissionCategoriesOf;
+exports.emissionCategoryValue = emissionCategoryValue;
+exports.escape = escape;
+exports.getColor = getColor;
+exports.groupDataByCategory = groupDataByCategory;
+exports.groupLogsById = groupLogsById;
+exports.hasNegativeContributions = hasNegativeContributions;
+exports.hexToRgba = hexToRgba;
+exports.horizontalBarHeight = horizontalBarHeight;
+exports.increaseScaleLimits = increaseScaleLimits;
+exports.indicatorLogs = indicatorLogs;
+exports.listColor = listColor;
+exports.listColorContinuous = listColorContinuous;
+exports.listColorWithAlpha = listColorWithAlpha;
+exports.logToCsv = logToCsv;
+exports.logsTotalValue = logsTotalValue;
+exports.lollipopChartPlugin = lollipopChartPlugin;
+exports.namedContributors = namedContributors;
+exports.nonZeroContributors = nonZeroContributors;
+exports.parseColor = parseColor;
+exports.parseContributions = parseContributions;
+exports.sumValues = sumValues;
+exports.toLine = toLine;
+exports.valueRatio = valueRatio;
+exports.withOthers = withOthers;