@netdata/charts/dist/es6/components/headlessChart/useHeadlessChart.js

Netdata frontend SDK and chart utilities

function _toArray(r) { return _arrayWithHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableRest(); }
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
import { useMemo } from "react";
import { useChart, usePayload, useAttributeValue, useDimensionIds, useIsFetching, useEmpty } from "../provider";
export var useHeadlessChart = function useHeadlessChart() {
  var chart = useChart();
  var payload = usePayload();
  var dimensionIds = useDimensionIds();
  var hover = useAttributeValue("hoverX");
  var helpers = useMemo(function () {
    return {
      updateAttribute: chart.updateAttribute.bind(chart),
      getAttribute: chart.getAttribute.bind(chart),
      getDimensionIds: chart.getDimensionIds.bind(chart),
      getVisibleDimensionIds: chart.getVisibleDimensionIds.bind(chart),
      getDimensionValue: chart.getDimensionValue.bind(chart),
      getClosestRow: chart.getClosestRow.bind(chart),
      formatTime: chart.formatTime.bind(chart),
      formatDate: chart.formatDate.bind(chart),
      getConvertedValue: chart.getConvertedValue.bind(chart),
      selectDimensionColor: chart.selectDimensionColor.bind(chart),
      isDimensionVisible: chart.isDimensionVisible.bind(chart),
      focus: chart.focus.bind(chart),
      blur: chart.blur.bind(chart),
      getId: chart.getId.bind(chart),
      trigger: chart.trigger.bind(chart),
      on: chart.on.bind(chart),
      off: chart.off.bind(chart),
      onAttributeChange: chart.onAttributeChange.bind(chart),
      onceAttributeChange: chart.onceAttributeChange.bind(chart)
    };
  }, [chart]);
  var data = useMemo(function () {
    var _payload$data = payload.data,
      rawData = _payload$data === void 0 ? [] : _payload$data;
    if (!rawData.length) return [];
    var visibleDimensionIds = chart.getVisibleDimensionIds();
    var currentRowIndex = hover ? chart.getClosestRow(hover[0]) : rawData.length - 1;
    return rawData.map(function (row, rowIndex) {
      var _row = _toArray(row),
        timestamp = _row[0],
        values = _row.slice(1);
      var isCurrentRow = rowIndex === currentRowIndex;
      var dimensions = visibleDimensionIds.map(function (dimensionId) {
        var value = chart.getDimensionValue(dimensionId, rowIndex);
        return {
          id: dimensionId,
          value: value,
          convertedValue: chart.getConvertedValue(value),
          color: chart.selectDimensionColor(dimensionId),
          visible: chart.isDimensionVisible(dimensionId)
        };
      });
      return {
        timestamp: timestamp,
        formattedTime: chart.formatTime(timestamp),
        formattedDate: chart.formatDate(timestamp),
        values: values,
        dimensions: dimensions,
        isCurrentRow: isCurrentRow,
        rowIndex: rowIndex
      };
    });
  }, [payload, hover, chart]);
  var currentRow = useMemo(function () {
    if (!data.length) return null;
    return data.find(function (row) {
      return row.isCurrentRow;
    }) || data[data.length - 1];
  }, [data]);
  var loading = useIsFetching();
  var empty = useEmpty();
  var loaded = useAttributeValue("loaded");
  var error = useAttributeValue("error");
  var showingInfo = useAttributeValue("showingInfo");
  var focused = useAttributeValue("focused");
  var state = useMemo(function () {
    return {
      loading: loading,
      empty: empty,
      loaded: loaded,
      error: error,
      showingInfo: showingInfo,
      focused: focused
    };
  }, [loading, empty, loaded, error, showingInfo, focused]);
  return {
    chart: chart,
    data: data,
    currentRow: currentRow,
    dimensionIds: dimensionIds,
    hover: hover,
    helpers: helpers,
    state: state,
    attributes: chart.getAttributes()
  };
};
export default useHeadlessChart;