@widergy/energy-ui 3.158.1 → 3.160.0

package/dist/esm/components/UTGraph/components/Bars/index.js

@@ -0,0 +1,108 @@
+import * as d3 from 'd3';
+import { func, object, array } from 'prop-types';
+import React, { useMemo } from 'react';
+import { getRowList, getClusters, getValuesMapByCategory } from '../../utils';
+import { BAR_TYPE, DOMAIN_CATEGORICAL, MIN_BAR_WIDTH, MAX_BAR_WIDTH } from '../../constants';
+import { renderStacksForSideCategorical, renderStacksForSideNumerical } from './utils';
+const Bars = _ref => {
+  let {
+    crossAxisLeft,
+    crossAxisRight,
+    dataset,
+    mainAxis,
+    mainAxisDomain,
+    tab,
+    color
+  } = _ref;
+  const valuesByCategory = useMemo(() => getValuesMapByCategory(dataset), [dataset]);
+  const rows = useMemo(() => getRowList(dataset), [dataset]);
+  const splitBarClusters = useMemo(() => getClusters(tab, BAR_TYPE));
+  const widthScale = useMemo(() => {
+    if (tab.domain.binding === DOMAIN_CATEGORICAL) return null;
+    const values = [];
+    splitBarClusters.forEach(_ref2 => {
+      let {
+        leftItems,
+        rightItems
+      } = _ref2;
+      [...leftItems, ...rightItems].forEach(item => {
+        if (!item.sizeCode) return;
+        rows.forEach(r => {
+          const val = r[item.sizeCode];
+          if (Number.isFinite(val)) values.push(val);
+        });
+      });
+    });
+    if (values.length === 0) return null;
+    const [min, max] = d3.extent(values);
+    if (!Number.isFinite(min) || !Number.isFinite(max)) return null;
+    return d3.scaleLinear().domain([min, max]).range([MIN_BAR_WIDTH, MAX_BAR_WIDTH]).clamp(true);
+  }, [tab.domain.binding, splitBarClusters, rows]);
+  const clusterScale = useMemo(() => {
+    const count = tab.subitems.length;
+    return tab.domain.binding === DOMAIN_CATEGORICAL ? d3.scaleBand().domain(d3.range(count)).range([0, mainAxis.bandwidth()]).padding(0.15) : null;
+  }, [tab, mainAxis]);
+  return /*#__PURE__*/React.createElement("g", null, tab.domain.binding === DOMAIN_CATEGORICAL ? mainAxisDomain.map(category => {
+    const categoryXPosition = mainAxis(category);
+    const valuesByCode = valuesByCategory.get(category);
+    return splitBarClusters.map((_ref3, clusterIndex) => {
+      let {
+        leftItems,
+        rightItems
+      } = _ref3;
+      const x = categoryXPosition + clusterScale(clusterIndex);
+      const w = clusterScale.bandwidth();
+      return /*#__PURE__*/React.createElement("g", {
+        key: "".concat(category, "-cluster")
+      }, renderStacksForSideCategorical({
+        items: leftItems,
+        valuesByCode,
+        x,
+        w,
+        crossAxis: crossAxisLeft,
+        category,
+        color
+      }), renderStacksForSideCategorical({
+        items: rightItems,
+        valuesByCode,
+        x,
+        w,
+        crossAxis: crossAxisRight,
+        category,
+        color
+      }));
+    });
+  }) : splitBarClusters.map(_ref4 => {
+    let {
+      leftItems,
+      rightItems
+    } = _ref4;
+    return /*#__PURE__*/React.createElement("g", {
+      key: "num-cluster"
+    }, renderStacksForSideNumerical({
+      items: leftItems,
+      rows,
+      mainAxis,
+      crossAxis: crossAxisLeft,
+      color,
+      widthScale
+    }), renderStacksForSideNumerical({
+      items: rightItems,
+      rows,
+      mainAxis,
+      crossAxis: crossAxisRight,
+      color,
+      widthScale
+    }));
+  }));
+};
+Bars.propTypes = {
+  crossAxisLeft: func,
+  crossAxisRight: func,
+  dataset: object,
+  mainAxis: func,
+  mainAxisDomain: array,
+  tab: object,
+  color: func
+};
+export default Bars;

package/dist/esm/components/UTGraph/components/Bars/utils.js

@@ -0,0 +1,77 @@
+import * as d3 from 'd3';
+import React from 'react';
+import { DEFAULT_BAR_WIDTH } from '../../constants';
+export const renderStacksForSideCategorical = _ref => {
+  let {
+    items,
+    valuesByCode,
+    x,
+    w,
+    crossAxis,
+    category,
+    color
+  } = _ref;
+  const codes = items.map(_ref2 => {
+    let {
+      rangeCode
+    } = _ref2;
+    return rangeCode;
+  });
+  const stacks = d3.stack().keys(codes).offset(d3.stackOffsetDiverging)([valuesByCode]);
+  return stacks.map(series => {
+    const code = series.key;
+    const [y0, y1] = series[0];
+    const yTop = Math.min(crossAxis(y0), crossAxis(y1));
+    const yBot = Math.max(crossAxis(y0), crossAxis(y1));
+    const h = yBot - yTop;
+    return /*#__PURE__*/React.createElement("rect", {
+      key: "".concat(category, "-").concat(code),
+      x: x,
+      y: yTop,
+      width: w,
+      height: h,
+      fill: color(code)
+    });
+  });
+};
+export const renderStacksForSideNumerical = _ref3 => {
+  let {
+    items,
+    rows,
+    mainAxis,
+    crossAxis,
+    color,
+    widthScale
+  } = _ref3;
+  const yZero = crossAxis(0);
+  return items.map(_ref4 => {
+    let {
+      rangeCode,
+      domainCode,
+      sizeCode
+    } = _ref4;
+    if (!domainCode) return null;
+    return /*#__PURE__*/React.createElement("g", {
+      key: "num-bars-".concat(rangeCode)
+    }, rows.map(row => {
+      const xVal = row[domainCode];
+      const yVal = row[rangeCode];
+      if (!Number.isFinite(xVal) || !Number.isFinite(yVal)) return null;
+      const cx = mainAxis(xVal);
+      if (!Number.isFinite(cx)) return null;
+      const yTop = Math.min(crossAxis(yVal), yZero);
+      const yBot = Math.max(crossAxis(yVal), yZero);
+      const h = yBot - yTop;
+      if (h <= 0) return null;
+      const w = widthScale && sizeCode && Number.isFinite(row[sizeCode]) ? widthScale(row[sizeCode]) : DEFAULT_BAR_WIDTH;
+      return /*#__PURE__*/React.createElement("rect", {
+        key: "num-bar-".concat(rangeCode),
+        x: cx - w / 2,
+        y: yTop,
+        width: w,
+        height: h,
+        fill: color(rangeCode)
+      });
+    }));
+  });
+};

package/dist/esm/components/UTGraph/components/CartesianPlane/index.js

@@ -0,0 +1,109 @@
+import React, { useEffect, useMemo, useRef } from 'react';
+import * as d3 from 'd3';
+import { array, bool, func, number, object, string } from 'prop-types';
+import { DOMAIN_NUMERICAL } from '../../constants';
+const CartesianPlane = _ref => {
+  var _tab$domain2;
+  let {
+    mainAxisDomain,
+    crossAxisLeftDomain,
+    crossAxisRightDomain,
+    width,
+    height,
+    margin,
+    crossAxisLeftTicks,
+    crossAxisLeftTickFormat,
+    crossAxisRightTicks,
+    crossAxisRightTickFormat,
+    mainAxisTicks,
+    mainAxisTickFormat,
+    hasLeft,
+    hasRight,
+    tab,
+    children
+  } = _ref;
+  const innerWidth = width - margin.left - margin.right;
+  const innerHeight = height - margin.top - margin.bottom;
+  const mainAxis = useMemo(() => {
+    var _tab$domain;
+    return ((_tab$domain = tab.domain) === null || _tab$domain === void 0 ? void 0 : _tab$domain.binding) === DOMAIN_NUMERICAL ? d3.scaleLinear().domain(mainAxisDomain).range([0, innerWidth]).nice() : d3.scaleBand().domain(mainAxisDomain).range([0, innerWidth]).padding(0.1);
+  },
+  // TBD: parametrizar padding
+  [mainAxisDomain, innerWidth, (_tab$domain2 = tab.domain) === null || _tab$domain2 === void 0 ? void 0 : _tab$domain2.binding]);
+  const crossAxisLeft = useMemo(() => d3.scaleLinear().domain(crossAxisLeftDomain).range([innerHeight, 0]).nice(), [crossAxisLeftDomain, innerHeight]);
+  const crossAxisRight = useMemo(() => d3.scaleLinear().domain(crossAxisRightDomain).range([innerHeight, 0]).nice(), [crossAxisRightDomain, innerHeight]);
+  const mainAxisRef = useRef(null);
+  const crossAxisLeftRef = useRef(null);
+  const crossAxisRightRef = useRef(null);
+  const gridRef = useRef(null);
+  useEffect(() => {
+    const axis = d3.axisBottom(mainAxis).ticks(mainAxisTicks, mainAxisTickFormat).tickSizeOuter(0);
+    d3.select(mainAxisRef.current).call(axis);
+  }, [mainAxis, mainAxisTicks, mainAxisTickFormat]);
+  useEffect(() => {
+    if (!hasLeft) return;
+    const axis = d3.axisLeft(crossAxisLeft).ticks(crossAxisLeftTicks, crossAxisLeftTickFormat).tickSize(0).tickSizeOuter(0);
+    d3.select(crossAxisLeftRef.current).call(axis);
+    d3.select(crossAxisLeftRef.current).selectAll('.tick text').attr('text-anchor', 'end');
+  }, [crossAxisLeft, crossAxisLeftTicks, crossAxisLeftTickFormat]);
+  useEffect(() => {
+    if (!hasRight) return;
+    const axis = d3.axisRight(crossAxisRight).ticks(crossAxisRightTicks, crossAxisRightTickFormat).tickSize(0).tickSizeOuter(0);
+    d3.select(crossAxisRightRef.current).call(axis);
+    d3.select(crossAxisRightRef.current).selectAll('.tick text').attr('text-anchor', 'start');
+  }, [crossAxisRight, crossAxisRightTicks, crossAxisRightTickFormat]);
+  useEffect(() => {
+    const crossAxis = hasLeft ? crossAxisLeft : hasRight ? crossAxisRight : null;
+    const crossAxisTicks = hasLeft ? crossAxisLeftTicks : crossAxisRightTicks;
+    const g = d3.select(gridRef.current);
+    g.selectAll('*').remove();
+    if (!crossAxis) return;
+    const grid = d3.axisLeft(crossAxis).ticks(crossAxisTicks).tickFormat('').tickSize(-innerWidth).tickSizeOuter(0);
+    g.call(grid);
+    g.selectAll('.tick line').attr('stroke', '#000').attr('stroke-opacity', 0.5).attr('stroke-dasharray', '5 5');
+    g.select('.domain').remove();
+  }, [crossAxisLeft, crossAxisRight, innerWidth, crossAxisLeftTicks, crossAxisRightTicks]);
+  return /*#__PURE__*/React.createElement("svg", {
+    width: width,
+    height: height
+  }, /*#__PURE__*/React.createElement("g", {
+    transform: "translate(".concat(margin.left, ",").concat(margin.top, ")")
+  }, /*#__PURE__*/React.createElement("g", {
+    ref: gridRef,
+    className: "y-grid"
+  }), hasLeft && /*#__PURE__*/React.createElement("g", {
+    ref: crossAxisLeftRef,
+    className: "y-axis-left"
+  }), hasRight && /*#__PURE__*/React.createElement("g", {
+    ref: crossAxisRightRef,
+    className: "y-axis-right",
+    transform: "translate(".concat(innerWidth, ", 0)")
+  }), /*#__PURE__*/React.createElement("g", {
+    ref: mainAxisRef,
+    className: "x-axis",
+    transform: "translate(0, ".concat(innerHeight, ")")
+  }), children({
+    mainAxis,
+    crossAxisLeft,
+    crossAxisRight
+  })));
+};
+CartesianPlane.propTypes = {
+  crossAxisLeftDomain: array,
+  crossAxisLeftTicks: array,
+  crossAxisLeftTickFormat: string,
+  crossAxisRightDomain: array,
+  crossAxisRightTicks: array,
+  crossAxisRightTickFormat: string,
+  mainAxisDomain: array,
+  mainAxisTicks: array,
+  mainAxisTickFormat: string,
+  margin: object,
+  width: number,
+  height: number,
+  hasLeft: bool,
+  hasRight: bool,
+  tab: object,
+  children: func
+};
+export default CartesianPlane;

package/dist/esm/components/UTGraph/components/Lines/index.js

@@ -0,0 +1,53 @@
+import React, { useMemo } from 'react';
+import { object, func, array } from 'prop-types';
+import { DOMAIN_CATEGORICAL, LINE_TYPE } from '../../constants';
+import { getRowList, getClusters, getValuesMapByCategory } from '../../utils';
+import { renderStacksForSideCategorical, renderStacksForSideNumerical } from './utils';
+const Lines = _ref => {
+  let {
+    tab,
+    dataset,
+    mainAxis,
+    crossAxisLeft,
+    crossAxisRight,
+    mainAxisDomain,
+    color
+  } = _ref;
+  const valuesByCategory = useMemo(() => getValuesMapByCategory(dataset), [dataset]);
+  const rows = useMemo(() => getRowList(dataset), [dataset]);
+  const splitLineClusters = useMemo(() => getClusters(tab, LINE_TYPE), [tab]);
+  const renderStacksForSide = useMemo(() => tab.domain.binding === DOMAIN_CATEGORICAL ? renderStacksForSideCategorical : renderStacksForSideNumerical, [tab.domain.binding]);
+  return /*#__PURE__*/React.createElement("g", null, splitLineClusters.map(_ref2 => {
+    let {
+      leftItems,
+      rightItems
+    } = _ref2;
+    return /*#__PURE__*/React.createElement("g", null, renderStacksForSide({
+      items: leftItems,
+      rows,
+      valuesByCategory,
+      mainAxis,
+      mainAxisDomain,
+      crossAxis: crossAxisLeft,
+      color
+    }), renderStacksForSide({
+      items: rightItems,
+      rows,
+      valuesByCategory,
+      mainAxis,
+      mainAxisDomain,
+      crossAxis: crossAxisRight,
+      color
+    }));
+  }));
+};
+Lines.propTypes = {
+  tab: object,
+  dataset: object,
+  mainAxis: func,
+  crossAxisLeft: func,
+  crossAxisRight: func,
+  mainAxisDomain: array,
+  color: func
+};
+export default Lines;

package/dist/esm/components/UTGraph/components/Lines/utils.js

@@ -0,0 +1,84 @@
+import React from 'react';
+import * as d3 from 'd3';
+export const renderStacksForSideCategorical = _ref => {
+  let {
+    items,
+    valuesByCategory,
+    mainAxis,
+    mainAxisDomain,
+    crossAxis,
+    color
+  } = _ref;
+  const codes = items.map(_ref2 => {
+    let {
+      rangeCode
+    } = _ref2;
+    return rangeCode;
+  });
+  const rows = mainAxisDomain.map(category => {
+    const valuesByCode = valuesByCategory.get(category);
+    const row = {};
+    codes.forEach(code => row[code] = valuesByCode[code]);
+    return row;
+  });
+  const stacks = d3.stack().keys(codes).offset(d3.stackOffsetDiverging)(rows);
+  return stacks.map(series => {
+    const code = series.key;
+    const points = series.map((_ref3, i) => {
+      var _mainAxis$bandwidth, _mainAxis$bandwidth2;
+      let [y0, y1] = _ref3;
+      return {
+        y: Math.max(y0, y1),
+        x: mainAxis(mainAxisDomain[i]) + ((_mainAxis$bandwidth = (_mainAxis$bandwidth2 = mainAxis.bandwidth) === null || _mainAxis$bandwidth2 === void 0 ? void 0 : _mainAxis$bandwidth2.call(mainAxis)) !== null && _mainAxis$bandwidth !== void 0 ? _mainAxis$bandwidth : 0) / 2
+      };
+    });
+    const path = d3.line().defined(d => Number.isFinite(d.y)).x(d => d.x).y(d => crossAxis(d.y))(points);
+    if (!path) return null;
+    return /*#__PURE__*/React.createElement("path", {
+      key: code,
+      d: path,
+      fill: "none",
+      stroke: color(code),
+      strokeWidth: 2,
+      strokeLinejoin: "round",
+      strokeLinecap: "round"
+    });
+  });
+};
+export const renderStacksForSideNumerical = _ref4 => {
+  let {
+    items,
+    rows,
+    mainAxis,
+    crossAxis,
+    color
+  } = _ref4;
+  return items.map(_ref5 => {
+    let {
+      rangeCode,
+      domainCode
+    } = _ref5;
+    if (!domainCode) return null;
+    const points = rows.map(r => {
+      const xVal = r[domainCode];
+      const yVal = r[rangeCode];
+      if (!Number.isFinite(xVal) || !Number.isFinite(yVal)) return null;
+      return {
+        x: mainAxis(xVal),
+        y: crossAxis(yVal)
+      };
+    }).filter(Boolean).sort((a, b) => a.x - b.x);
+    if (points.length < 2) return null;
+    const path = d3.line().defined(d => Number.isFinite(d.x) && Number.isFinite(d.y)).x(d => d.x).y(d => d.y)(points);
+    if (!path) return null;
+    return /*#__PURE__*/React.createElement("path", {
+      key: "num-".concat(rangeCode, "-").concat(domainCode),
+      d: path,
+      fill: "none",
+      stroke: color(rangeCode),
+      strokeWidth: 2,
+      strokeLinejoin: "round",
+      strokeLinecap: "round"
+    });
+  });
+};

package/dist/esm/components/UTGraph/components/Points/constants.js

@@ -0,0 +1,3 @@
+export const DEFAULT_RADIUS = 5;
+export const MIN_RADIUS = 5;
+export const MAX_RADIUS = 20;

package/dist/esm/components/UTGraph/components/Points/index.js

@@ -0,0 +1,68 @@
+import React, { useMemo } from 'react';
+import * as d3 from 'd3';
+import { object, func, array } from 'prop-types';
+import { getRowList, getClusters, getValuesMapByCategory } from '../../utils';
+import { DOMAIN_CATEGORICAL, POINT_TYPE } from '../../constants';
+import { getSizeExtent, renderPointsForSideCategorical, renderPointsForSideNumerical } from './utils';
+import { MAX_RADIUS, MIN_RADIUS } from './constants';
+const Points = _ref => {
+  let {
+    tab,
+    dataset,
+    mainAxis,
+    mainAxisDomain,
+    crossAxisLeft,
+    crossAxisRight,
+    color
+  } = _ref;
+  const valuesByCategory = useMemo(() => getValuesMapByCategory(dataset), [dataset]);
+  const rows = useMemo(() => getRowList(dataset), [dataset]);
+  const splitPointClusters = useMemo(() => getClusters(tab, POINT_TYPE), [tab]);
+  const sizeExtent = useMemo(() => getSizeExtent({
+    tab,
+    splitPointClusters,
+    valuesByCategory,
+    mainAxisDomain,
+    rows
+  }), [splitPointClusters, mainAxisDomain, valuesByCategory, rows]);
+  const sizeScale = useMemo(() => {
+    if (!sizeExtent) return null;
+    return d3.scaleSqrt().domain(sizeExtent).range([MIN_RADIUS, MAX_RADIUS]).clamp(true);
+  }, [sizeExtent]);
+  const renderPointsForSide = useMemo(() => tab.domain.binding === DOMAIN_CATEGORICAL ? renderPointsForSideCategorical : renderPointsForSideNumerical, [tab.domain.binding]);
+  return /*#__PURE__*/React.createElement("g", null, splitPointClusters.map(_ref2 => {
+    let {
+      leftItems,
+      rightItems
+    } = _ref2;
+    return /*#__PURE__*/React.createElement("g", null, renderPointsForSide({
+      items: leftItems,
+      valuesByCategory,
+      mainAxis,
+      mainAxisDomain,
+      crossAxis: crossAxisLeft,
+      color,
+      sizeScale,
+      rows
+    }), renderPointsForSide({
+      items: rightItems,
+      valuesByCategory,
+      mainAxis,
+      mainAxisDomain,
+      crossAxis: crossAxisRight,
+      color,
+      sizeScale,
+      rows
+    }));
+  }));
+};
+Points.propTypes = {
+  dataset: object,
+  tab: object,
+  mainAxis: func,
+  mainAxisDomain: array,
+  crossAxisLeft: func,
+  crossAxisRight: func,
+  color: func
+};
+export default Points;

package/dist/esm/components/UTGraph/components/Points/utils.js

@@ -0,0 +1,136 @@
+import React from 'react';
+import * as d3 from 'd3';
+import { DOMAIN_CATEGORICAL } from '../../constants';
+import { DEFAULT_RADIUS } from './constants';
+export const renderPointsForSideCategorical = _ref => {
+  let {
+    items,
+    valuesByCategory,
+    mainAxis,
+    mainAxisDomain,
+    crossAxis,
+    color,
+    sizeScale
+  } = _ref;
+  return items.map(_ref2 => {
+    let {
+      rangeCode,
+      sizeCode,
+      colorCode
+    } = _ref2;
+    return /*#__PURE__*/React.createElement("g", {
+      key: "points-".concat(rangeCode)
+    }, mainAxisDomain.map(category => {
+      var _mainAxis$bandwidth, _mainAxis$bandwidth2;
+      const row = valuesByCategory.get(category);
+      if (!row) return null;
+      const yVal = row[rangeCode];
+      if (!Number.isFinite(yVal)) return null;
+      const sizeVal = sizeCode ? row[sizeCode] : undefined;
+      const r = sizeCode && Number.isFinite(sizeVal) && sizeScale ? sizeScale(sizeVal) : DEFAULT_RADIUS;
+      const cx = mainAxis(category) + ((_mainAxis$bandwidth = (_mainAxis$bandwidth2 = mainAxis.bandwidth) === null || _mainAxis$bandwidth2 === void 0 ? void 0 : _mainAxis$bandwidth2.call(mainAxis)) !== null && _mainAxis$bandwidth !== void 0 ? _mainAxis$bandwidth : 0) / 2;
+      const cy = crossAxis(yVal);
+      const colorKey = colorCode && row[colorCode] != null ? row[colorCode] : rangeCode;
+      return /*#__PURE__*/React.createElement("circle", {
+        key: "pt-".concat(rangeCode, "-").concat(category),
+        cx: cx,
+        cy: cy,
+        r: r,
+        fill: color(colorKey)
+      });
+    }));
+  });
+};
+export const renderPointsForSideNumerical = _ref3 => {
+  let {
+    items,
+    rows,
+    mainAxis,
+    crossAxis,
+    color,
+    sizeScale
+  } = _ref3;
+  return items.map(_ref4 => {
+    let {
+      rangeCode,
+      sizeCode,
+      domainCode,
+      colorCode
+    } = _ref4;
+    return /*#__PURE__*/React.createElement("g", {
+      key: "points-num-".concat(rangeCode)
+    }, rows.map(row => {
+      const xVal = row[domainCode];
+      const yVal = row[rangeCode];
+      if (!Number.isFinite(xVal) || !Number.isFinite(yVal)) return null;
+      const sizeVal = sizeCode ? row[sizeCode] : undefined;
+      const r = sizeCode && Number.isFinite(sizeVal) && sizeScale ? sizeScale(sizeVal) : DEFAULT_RADIUS;
+      const cx = mainAxis(xVal);
+      const cy = crossAxis(yVal);
+      const colorKey = colorCode && row[colorCode] != null ? row[colorCode] : rangeCode;
+      return /*#__PURE__*/React.createElement("circle", {
+        key: "pt-num-".concat(rangeCode),
+        cx: cx,
+        cy: cy,
+        r: r,
+        fill: color(colorKey)
+      });
+    }));
+  });
+};
+const getSizeValues = _ref5 => {
+  let {
+    tab,
+    splitPointClusters,
+    mainAxisDomain,
+    valuesByCategory,
+    rows
+  } = _ref5;
+  const values = [];
+  splitPointClusters.forEach(_ref6 => {
+    let {
+      leftItems,
+      rightItems
+    } = _ref6;
+    [...leftItems, ...rightItems].forEach(item => {
+      if (!item.sizeCode) return;
+      if (tab.domain.binding === DOMAIN_CATEGORICAL) {
+        mainAxisDomain.forEach(category => {
+          const row = valuesByCategory.get(category);
+          const val = row === null || row === void 0 ? void 0 : row[item.sizeCode];
+          if (Number.isFinite(val)) values.push(val);
+        });
+      } else {
+        rows.forEach(row => {
+          const val = row === null || row === void 0 ? void 0 : row[item.sizeCode];
+          if (Number.isFinite(val)) values.push(val);
+        });
+      }
+    });
+  });
+  return values;
+};
+const getMinMaxValues = values => {
+  if (values.length === 0) return null;
+  const [min, max] = d3.extent(values);
+  if (!Number.isFinite(min) || !Number.isFinite(max)) return null;
+  if (min === max) return [min, max + 1];
+  return [min, max];
+};
+export const getSizeExtent = _ref7 => {
+  let {
+    tab,
+    splitPointClusters,
+    valuesByCategory,
+    mainAxisDomain,
+    rows
+  } = _ref7;
+  const values = getSizeValues({
+    tab,
+    splitPointClusters,
+    mainAxisDomain,
+    valuesByCategory,
+    rows
+  });
+  return getMinMaxValues(values);
+};

package/dist/esm/components/UTGraph/components/RadialChart/constants.js

@@ -0,0 +1,4 @@
+export const BASE_INNER_RADIUS_RATIO = 0.45;
+export const CORNER_RADIUS = 4;
+export const PAD_ANGLE = 0.01;
+export const RING_GAP = 3;