@widergy/energy-ui 3.173.2 → 3.173.4

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

@@ -1,109 +1 @@
-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;
+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=e=>{var t;let{mainAxisDomain:s,crossAxisLeftDomain:i,crossAxisRightDomain:a,width:r,height:c,margin:n,crossAxisLeftTicks:o,crossAxisLeftTickFormat:l,crossAxisRightTicks:m,crossAxisRightTickFormat:f,mainAxisTicks:u,mainAxisTickFormat:d,hasLeft:g,hasRight:x,tab:h,children:k}=e;const A=r-n.left-n.right,R=c-n.top-n.bottom,L=useMemo(()=>{var e;return(null===(e=h.domain)||void 0===e?void 0:e.binding)===DOMAIN_NUMERICAL?d3.scaleLinear().domain(s).range([0,A]).nice():d3.scaleBand().domain(s).range([0,A]).padding(.1)},[s,A,null===(t=h.domain)||void 0===t?void 0:t.binding]),p=useMemo(()=>d3.scaleLinear().domain(i).range([R,0]).nice(),[i,R]),b=useMemo(()=>d3.scaleLinear().domain(a).range([R,0]).nice(),[a,R]),y=useRef(null),E=useRef(null),T=useRef(null),v=useRef(null);return useEffect(()=>{const e=d3.axisBottom(L).ticks(u,d).tickSizeOuter(0);d3.select(y.current).call(e)},[L,u,d]),useEffect(()=>{if(!g)return;const e=d3.axisLeft(p).ticks(o,l).tickSize(0).tickSizeOuter(0);d3.select(E.current).call(e),d3.select(E.current).selectAll(".tick text").attr("text-anchor","end")},[p,o,l]),useEffect(()=>{if(!x)return;const e=d3.axisRight(b).ticks(m,f).tickSize(0).tickSizeOuter(0);d3.select(T.current).call(e),d3.select(T.current).selectAll(".tick text").attr("text-anchor","start")},[b,m,f]),useEffect(()=>{const e=g?p:x?b:null,t=g?o:m,s=d3.select(v.current);if(s.selectAll("*").remove(),!e)return;const i=d3.axisLeft(e).ticks(t).tickFormat("").tickSize(-A).tickSizeOuter(0);s.call(i),s.selectAll(".tick line").attr("stroke","#000").attr("stroke-opacity",.5).attr("stroke-dasharray","5 5"),s.select(".domain").remove()},[p,b,A,o,m]),React.createElement("svg",{width:r,height:c},React.createElement("g",{transform:"translate(".concat(n.left,",").concat(n.top,")")},React.createElement("g",{ref:v,className:"y-grid"}),g&&React.createElement("g",{ref:E,className:"y-axis-left"}),x&&React.createElement("g",{ref:T,className:"y-axis-right",transform:"translate(".concat(A,", 0)")}),React.createElement("g",{ref:y,className:"x-axis",transform:"translate(0, ".concat(R,")")}),k({mainAxis:L,crossAxisLeft:p,crossAxisRight:b})))};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

@@ -1,53 +1 @@
-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;
+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=e=>{let{tab:t,dataset:s,mainAxis:r,crossAxisLeft:o,crossAxisRight:i,mainAxisDomain:a,color:n}=e;const m=useMemo(()=>getValuesMapByCategory(s),[s]),c=useMemo(()=>getRowList(s),[s]),l=useMemo(()=>getClusters(t,LINE_TYPE),[t]),u=useMemo(()=>t.domain.binding===DOMAIN_CATEGORICAL?renderStacksForSideCategorical:renderStacksForSideNumerical,[t.domain.binding]);return React.createElement("g",null,l.map(e=>{let{leftItems:t,rightItems:s}=e;return React.createElement("g",null,u({items:t,rows:c,valuesByCategory:m,mainAxis:r,mainAxisDomain:a,crossAxis:o,color:n}),u({items:s,rows:c,valuesByCategory:m,mainAxis:r,mainAxisDomain:a,crossAxis:i,color:n}))}))};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

@@ -1,84 +1 @@
-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"
-    });
-  });
-};
+import React from"react";import*as d3 from"d3";export const renderStacksForSideCategorical=e=>{let{items:t,valuesByCategory:r,mainAxis:n,mainAxisDomain:i,crossAxis:o,color:s}=e;const a=t.map(e=>{let{rangeCode:t}=e;return t}),l=i.map(e=>{const t=r.get(e),n={};return a.forEach(e=>n[e]=t[e]),n});return d3.stack().keys(a).offset(d3.stackOffsetDiverging)(l).map(e=>{const t=e.key,r=e.map((e,t)=>{var r,o;let[s,a]=e;return{y:Math.max(s,a),x:n(i[t])+(null!==(r=null===(o=n.bandwidth)||void 0===o?void 0:o.call(n))&&void 0!==r?r:0)/2}}),a=d3.line().defined(e=>Number.isFinite(e.y)).x(e=>e.x).y(e=>o(e.y))(r);return a?React.createElement("path",{key:t,d:a,fill:"none",stroke:s(t),strokeWidth:2,strokeLinejoin:"round",strokeLinecap:"round"}):null})};export const renderStacksForSideNumerical=e=>{let{items:t,rows:r,mainAxis:n,crossAxis:i,color:o}=e;return t.map(e=>{let{rangeCode:t,domainCode:s}=e;if(!s)return null;const a=r.map(e=>{const r=e[s],o=e[t];return Number.isFinite(r)&&Number.isFinite(o)?{x:n(r),y:i(o)}:null}).filter(Boolean).sort((e,t)=>e.x-t.x);if(a.length<2)return null;const l=d3.line().defined(e=>Number.isFinite(e.x)&&Number.isFinite(e.y)).x(e=>e.x).y(e=>e.y)(a);return l?React.createElement("path",{key:"num-".concat(t,"-").concat(s),d:l,fill:"none",stroke:o(t),strokeWidth:2,strokeLinejoin:"round",strokeLinecap:"round"}):null})};

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

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

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

@@ -1,68 +1 @@
-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;
+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=e=>{let{tab:t,dataset:s,mainAxis:o,mainAxisDomain:i,crossAxisLeft:r,crossAxisRight:a,color:n}=e;const m=useMemo(()=>getValuesMapByCategory(s),[s]),c=useMemo(()=>getRowList(s),[s]),l=useMemo(()=>getClusters(t,POINT_TYPE),[t]),u=useMemo(()=>getSizeExtent({tab:t,splitPointClusters:l,valuesByCategory:m,mainAxisDomain:i,rows:c}),[l,i,m,c]),A=useMemo(()=>u?d3.scaleSqrt().domain(u).range([MIN_RADIUS,MAX_RADIUS]).clamp(!0):null,[u]),g=useMemo(()=>t.domain.binding===DOMAIN_CATEGORICAL?renderPointsForSideCategorical:renderPointsForSideNumerical,[t.domain.binding]);return React.createElement("g",null,l.map(e=>{let{leftItems:t,rightItems:s}=e;return React.createElement("g",null,g({items:t,valuesByCategory:m,mainAxis:o,mainAxisDomain:i,crossAxis:r,color:n,sizeScale:A,rows:c}),g({items:s,valuesByCategory:m,mainAxis:o,mainAxisDomain:i,crossAxis:a,color:n,sizeScale:A,rows:c}))}))};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

@@ -1,136 +1 @@
-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);
-};
+import React from"react";import*as d3 from"d3";import{DOMAIN_CATEGORICAL}from"../../constants";import{DEFAULT_RADIUS}from"./constants";export const renderPointsForSideCategorical=e=>{let{items:t,valuesByCategory:i,mainAxis:n,mainAxisDomain:r,crossAxis:o,color:s,sizeScale:a}=e;return t.map(e=>{let{rangeCode:t,sizeCode:l,colorCode:c}=e;return React.createElement("g",{key:"points-".concat(t)},r.map(e=>{var r,u;const m=i.get(e);if(!m)return null;const d=m[t];if(!Number.isFinite(d))return null;const C=l?m[l]:void 0,p=l&&Number.isFinite(C)&&a?a(C):DEFAULT_RADIUS,A=n(e)+(null!==(r=null===(u=n.bandwidth)||void 0===u?void 0:u.call(n))&&void 0!==r?r:0)/2,g=o(d),x=c&&null!=m[c]?m[c]:t;return React.createElement("circle",{key:"pt-".concat(t,"-").concat(e),cx:A,cy:g,r:p,fill:s(x)})}))})};export const renderPointsForSideNumerical=e=>{let{items:t,rows:i,mainAxis:n,crossAxis:r,color:o,sizeScale:s}=e;return t.map(e=>{let{rangeCode:t,sizeCode:a,domainCode:l,colorCode:c}=e;return React.createElement("g",{key:"points-num-".concat(t)},i.map(e=>{const i=e[l],u=e[t];if(!Number.isFinite(i)||!Number.isFinite(u))return null;const m=a?e[a]:void 0,d=a&&Number.isFinite(m)&&s?s(m):DEFAULT_RADIUS,C=n(i),p=r(u),A=c&&null!=e[c]?e[c]:t;return React.createElement("circle",{key:"pt-num-".concat(t),cx:C,cy:p,r:d,fill:o(A)})}))})};const getSizeValues=e=>{let{tab:t,splitPointClusters:i,mainAxisDomain:n,valuesByCategory:r,rows:o}=e;const s=[];return i.forEach(e=>{let{leftItems:i,rightItems:a}=e;[...i,...a].forEach(e=>{e.sizeCode&&(t.domain.binding===DOMAIN_CATEGORICAL?n.forEach(t=>{const i=r.get(t),n=null==i?void 0:i[e.sizeCode];Number.isFinite(n)&&s.push(n)}):o.forEach(t=>{const i=null==t?void 0:t[e.sizeCode];Number.isFinite(i)&&s.push(i)}))})}),s},getMinMaxValues=e=>{if(0===e.length)return null;const[t,i]=d3.extent(e);return Number.isFinite(t)&&Number.isFinite(i)?t===i?[t,i+1]:[t,i]:null};export const getSizeExtent=e=>{let{tab:t,splitPointClusters:i,valuesByCategory:n,mainAxisDomain:r,rows:o}=e;const s=getSizeValues({tab:t,splitPointClusters:i,mainAxisDomain:r,valuesByCategory:n,rows:o});return getMinMaxValues(s)};

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

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

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

@@ -1,132 +1 @@
-import React, { useMemo } from 'react';
-import * as d3 from 'd3';
-import { func, number, object } from 'prop-types';
-import UTLabel from '../../../UTLabel';
-import UTTooltip from '../../../UTTooltip';
-import UTIcon from '../../../UTIcon';
-import { TOOLTIP_SIZE } from '../../constants';
-import styles from './styles.module.scss';
-import { getValueMapByCode } from './utils';
-import { BASE_INNER_RADIUS_RATIO, CORNER_RADIUS, PAD_ANGLE, RING_GAP } from './constants';
-const RadialChart = _ref => {
-  var _configuration$baseIn, _configuration$corner, _configuration$padAng, _configuration$ringGa, _dataset$domain, _tab$configuration;
-  let {
-    tab,
-    width,
-    height,
-    dataset,
-    color,
-    configuration
-  } = _ref;
-  const cX = width / 2;
-  const cY = height / 2;
-  const outerRadius = Math.max(0, Math.min(cX, cY));
-  const baseInnerRadius = outerRadius * ((_configuration$baseIn = configuration === null || configuration === void 0 ? void 0 : configuration.baseInnerRadiusRatio) !== null && _configuration$baseIn !== void 0 ? _configuration$baseIn : BASE_INNER_RADIUS_RATIO);
-  const cornerRadius = (_configuration$corner = configuration === null || configuration === void 0 ? void 0 : configuration.cornerRadius) !== null && _configuration$corner !== void 0 ? _configuration$corner : CORNER_RADIUS;
-  const padAngle = (_configuration$padAng = configuration === null || configuration === void 0 ? void 0 : configuration.padAngle) !== null && _configuration$padAng !== void 0 ? _configuration$padAng : PAD_ANGLE;
-  const ringGap = (_configuration$ringGa = configuration === null || configuration === void 0 ? void 0 : configuration.ringGap) !== null && _configuration$ringGa !== void 0 ? _configuration$ringGa : RING_GAP;
-  const domainEntry = dataset === null || dataset === void 0 || (_dataset$domain = dataset.domain) === null || _dataset$domain === void 0 ? void 0 : _dataset$domain[0];
-  const clusters = useMemo(() => tab.subitems || [], [tab]);
-  const valueByCode = useMemo(() => getValueMapByCode(domainEntry === null || domainEntry === void 0 ? void 0 : domainEntry.concepts), [domainEntry]);
-  const pieInputsByCluster = useMemo(() => clusters.map(cluster => cluster.map(series => {
-    var _valueByCode$get;
-    const code = series.bindings.range;
-    return {
-      code,
-      value: Number((_valueByCode$get = valueByCode.get(code)) !== null && _valueByCode$get !== void 0 ? _valueByCode$get : 0)
-    };
-  })), [clusters, valueByCode]);
-  const pie = useMemo(() => d3.pie().value(d => d.value).sort(null).padAngle(padAngle), [padAngle]);
-  const ringCount = clusters.length || 1;
-  const totalRadialSpace = outerRadius - baseInnerRadius;
-  const ringThickness = Math.max(1, (totalRadialSpace - (ringCount - 1) * ringGap) / ringCount);
-  const innerMostRadius = outerRadius - ringCount * ringThickness - (ringCount - 1) * ringGap;
-  const rings = useMemo(() => pieInputsByCluster.map((pieInput, clusterIndex) => {
-    const visibleInput = pieInput.filter(d => d.value > 0);
-    const ringOuter = outerRadius - clusterIndex * (ringThickness + ringGap);
-    const ringInner = ringOuter - ringThickness;
-    const arcs = pie(visibleInput);
-    const arcGen = d3.arc().innerRadius(ringInner).outerRadius(ringOuter).cornerRadius(cornerRadius);
-    return {
-      clusterIndex,
-      arcs,
-      arcGen
-    };
-  }), [pieInputsByCluster, pie, outerRadius, ringThickness, ringGap, cornerRadius]);
-  const {
-    title,
-    tooltip,
-    value,
-    icon
-  } = ((_tab$configuration = tab.configuration) === null || _tab$configuration === void 0 ? void 0 : _tab$configuration.radialCenter) || {};
-  return /*#__PURE__*/React.createElement("div", {
-    style: {
-      position: 'relative',
-      width,
-      height
-    }
-  }, /*#__PURE__*/React.createElement("svg", {
-    width: width,
-    height: height
-  }, /*#__PURE__*/React.createElement("g", {
-    transform: "translate(".concat(cX, ", ").concat(cY, ")")
-  }, rings.map(_ref2 => {
-    let {
-      clusterIndex,
-      arcs,
-      arcGen
-    } = _ref2;
-    return /*#__PURE__*/React.createElement("g", {
-      key: "ring-".concat(clusterIndex)
-    }, arcs.map(arcDatum => {
-      const d = arcGen(arcDatum);
-      const {
-        code
-      } = arcDatum.data;
-      return /*#__PURE__*/React.createElement("path", {
-        key: code,
-        d: d,
-        fill: color(code),
-        stroke: "white",
-        strokeWidth: 1
-      });
-    }));
-  }))), /*#__PURE__*/React.createElement("div", {
-    style: {
-      position: 'absolute',
-      inset: 0,
-      display: 'flex',
-      flexDirection: 'column',
-      justifyContent: 'center',
-      alignItems: 'center'
-    }
-  }, title && /*#__PURE__*/React.createElement(UTLabel, {
-    weight: "medium",
-    variant: "xsmall",
-    colorTheme: "gray",
-    title: title
-  }, title), (value === null || value === void 0 ? void 0 : value.code) && /*#__PURE__*/React.createElement(UTLabel, {
-    weight: "medium",
-    variant: "title2",
-    title: value.code
-  }, value.format ? d3.format(value.format)(valueByCode.get(value.code)) : valueByCode.get(value.code)), tooltip && /*#__PURE__*/React.createElement(UTTooltip, {
-    content: tooltip
-  }, /*#__PURE__*/React.createElement("div", {
-    className: styles.tooltipIcon
-  }, /*#__PURE__*/React.createElement(UTIcon, {
-    name: "IconInfoCircle",
-    size: TOOLTIP_SIZE
-  }))), icon && /*#__PURE__*/React.createElement(UTIcon, {
-    name: icon,
-    size: Math.max(innerMostRadius - ringGap, 0)
-  })));
-};
-RadialChart.propTypes = {
-  tab: object,
-  width: number,
-  height: number,
-  dataset: object,
-  color: func,
-  configuration: object
-};
-export default RadialChart;
+import React,{useMemo}from"react";import*as d3 from"d3";import{func,number,object}from"prop-types";import UTLabel from"../../../UTLabel";import UTTooltip from"../../../UTTooltip";import UTIcon from"../../../UTIcon";import{TOOLTIP_SIZE}from"../../constants";import styles from"./styles.module.scss";import{getValueMapByCode}from"./utils";import{BASE_INNER_RADIUS_RATIO,CORNER_RADIUS,PAD_ANGLE,RING_GAP}from"./constants";const RadialChart=e=>{var t,a,o,n,l,r;let{tab:i,width:c,height:m,dataset:s,color:d,configuration:u}=e;const p=c/2,R=m/2,v=Math.max(0,Math.min(p,R)),f=v*(null!==(t=null==u?void 0:u.baseInnerRadiusRatio)&&void 0!==t?t:BASE_INNER_RADIUS_RATIO),g=null!==(a=null==u?void 0:u.cornerRadius)&&void 0!==a?a:CORNER_RADIUS,h=null!==(o=null==u?void 0:u.padAngle)&&void 0!==o?o:PAD_ANGLE,I=null!==(n=null==u?void 0:u.ringGap)&&void 0!==n?n:RING_GAP,E=null==s||null===(l=s.domain)||void 0===l?void 0:l[0],T=useMemo(()=>i.subitems||[],[i]),b=useMemo(()=>getValueMapByCode(null==E?void 0:E.concepts),[E]),A=useMemo(()=>T.map(e=>e.map(e=>{var t;const a=e.bindings.range;return{code:a,value:Number(null!==(t=b.get(a))&&void 0!==t?t:0)}})),[T,b]),U=useMemo(()=>d3.pie().value(e=>e.value).sort(null).padAngle(h),[h]),y=T.length||1,_=v-f,M=Math.max(1,(_-(y-1)*I)/y),N=v-y*M-(y-1)*I,C=useMemo(()=>A.map((e,t)=>{const a=e.filter(e=>e.value>0),o=v-t*(M+I),n=o-M;return{clusterIndex:t,arcs:U(a),arcGen:d3.arc().innerRadius(n).outerRadius(o).cornerRadius(g)}}),[A,U,v,M,I,g]),{title:x,tooltip:G,value:L,icon:O}=(null===(r=i.configuration)||void 0===r?void 0:r.radialCenter)||{};return React.createElement("div",{style:{position:"relative",width:c,height:m}},React.createElement("svg",{width:c,height:m},React.createElement("g",{transform:"translate(".concat(p,", ").concat(R,")")},C.map(e=>{let{clusterIndex:t,arcs:a,arcGen:o}=e;return React.createElement("g",{key:"ring-".concat(t)},a.map(e=>{const t=o(e),{code:a}=e.data;return React.createElement("path",{key:a,d:t,fill:d(a),stroke:"white",strokeWidth:1})}))}))),React.createElement("div",{style:{position:"absolute",inset:0,display:"flex",flexDirection:"column",justifyContent:"center",alignItems:"center"}},x&&React.createElement(UTLabel,{weight:"medium",variant:"xsmall",colorTheme:"gray",title:x},x),(null==L?void 0:L.code)&&React.createElement(UTLabel,{weight:"medium",variant:"title2",title:L.code},L.format?d3.format(L.format)(b.get(L.code)):b.get(L.code)),G&&React.createElement(UTTooltip,{content:G},React.createElement("div",{className:styles.tooltipIcon},React.createElement(UTIcon,{name:"IconInfoCircle",size:TOOLTIP_SIZE}))),O&&React.createElement(UTIcon,{name:O,size:Math.max(N-I,0)})))};RadialChart.propTypes={tab:object,width:number,height:number,dataset:object,color:func,configuration:object};export default RadialChart;

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

@@ -1,6 +1 @@
-export const getValueMapByCode = concepts => {
-  const map = new Map();
-  if (!concepts) return map;
-  concepts.forEach(concept => map.set(concept.code, concept.value));
-  return map;
-};
+export const getValueMapByCode=e=>{const o=new Map;return e?(e.forEach(e=>o.set(e.code,e.value)),o):o};

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

@@ -1,27 +1 @@
-import styles from './styles.module.scss';
-export const LEFT_SIDE = 'left';
-export const RIGHT_SIDE = 'right';
-export const LINE_TYPE = 'line';
-export const BAR_TYPE = 'bar';
-export const POINT_TYPE = 'point';
-export const DOMAIN_CATEGORICAL = 'categorical';
-export const DOMAIN_NUMERICAL = 'numerical';
-export const TOOLTIP_SIZE = 17;
-export const DEFAULT_DOMAIN_TICK_FORMAT = '~s';
-export const DEFAULT_DOMAIN_TICKS = 4;
-export const DEFAULT_RANGE_TICK_FORMAT = '~s';
-export const DEFAULT_RANGE_TICKS = 4;
-export const DEFAULT_CARTESIAN_PLANE_MARGINS = {
-  top: 24,
-  right: 24,
-  bottom: 24,
-  left: 24
-};
-export const MIN_BAR_WIDTH = 4;
-export const MAX_BAR_WIDTH = 20;
-export const DEFAULT_BAR_WIDTH = 10;
-export const LEGEND_TYPE_STYLES = {
-  [POINT_TYPE]: styles.legendPoint,
-  [BAR_TYPE]: styles.legendBar,
-  [LINE_TYPE]: styles.legendLine
-};
+import styles from"./styles.module.scss";export const LEFT_SIDE="left";export const RIGHT_SIDE="right";export const LINE_TYPE="line";export const BAR_TYPE="bar";export const POINT_TYPE="point";export const DOMAIN_CATEGORICAL="categorical";export const DOMAIN_NUMERICAL="numerical";export const TOOLTIP_SIZE=17;export const DEFAULT_DOMAIN_TICK_FORMAT="~s";export const DEFAULT_DOMAIN_TICKS=4;export const DEFAULT_RANGE_TICK_FORMAT="~s";export const DEFAULT_RANGE_TICKS=4;export const DEFAULT_CARTESIAN_PLANE_MARGINS={top:24,right:24,bottom:24,left:24};export const MIN_BAR_WIDTH=4;export const MAX_BAR_WIDTH=20;export const DEFAULT_BAR_WIDTH=10;export const LEGEND_TYPE_STYLES={[POINT_TYPE]:styles.legendPoint,[BAR_TYPE]:styles.legendBar,[LINE_TYPE]:styles.legendLine};