@widergy/energy-ui 3.172.2 → 3.172.3

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

@@ -1,108 +1 @@
-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;
+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:crossAxisLeft,crossAxisRight:crossAxisRight,dataset:dataset,mainAxis:mainAxis,mainAxisDomain:mainAxisDomain,tab:tab,color:color}=_ref;const valuesByCategory=useMemo(()=>getValuesMapByCategory(dataset),[dataset]),rows=useMemo(()=>getRowList(dataset),[dataset]),splitBarClusters=useMemo(()=>getClusters(tab,BAR_TYPE)),widthScale=useMemo(()=>{if(tab.domain.binding===DOMAIN_CATEGORICAL)return null;const values=[];if(splitBarClusters.forEach(_ref2=>{let{leftItems:leftItems,rightItems:rightItems}=_ref2;[...leftItems,...rightItems].forEach(item=>{item.sizeCode&&rows.forEach(r=>{const val=r[item.sizeCode];Number.isFinite(val)&&values.push(val)})})}),0===values.length)return null;const[min,max]=d3.extent(values);return Number.isFinite(min)&&Number.isFinite(max)?d3.scaleLinear().domain([min,max]).range([MIN_BAR_WIDTH,MAX_BAR_WIDTH]).clamp(!0):null},[tab.domain.binding,splitBarClusters,rows]),clusterScale=useMemo(()=>{const count=tab.subitems.length;return tab.domain.binding===DOMAIN_CATEGORICAL?d3.scaleBand().domain(d3.range(count)).range([0,mainAxis.bandwidth()]).padding(.15):null},[tab,mainAxis]);return React.createElement("g",null,tab.domain.binding===DOMAIN_CATEGORICAL?mainAxisDomain.map(category=>{const categoryXPosition=mainAxis(category),valuesByCode=valuesByCategory.get(category);return splitBarClusters.map((_ref3,clusterIndex)=>{let{leftItems:leftItems,rightItems:rightItems}=_ref3;const x=categoryXPosition+clusterScale(clusterIndex),w=clusterScale.bandwidth();return React.createElement("g",{key:"".concat(category,"-cluster")},renderStacksForSideCategorical({items:leftItems,valuesByCode:valuesByCode,x:x,w:w,crossAxis:crossAxisLeft,category:category,color:color}),renderStacksForSideCategorical({items:rightItems,valuesByCode:valuesByCode,x:x,w:w,crossAxis:crossAxisRight,category:category,color:color}))})}):splitBarClusters.map(_ref4=>{let{leftItems:leftItems,rightItems:rightItems}=_ref4;return React.createElement("g",{key:"num-cluster"},renderStacksForSideNumerical({items:leftItems,rows:rows,mainAxis:mainAxis,crossAxis:crossAxisLeft,color:color,widthScale:widthScale}),renderStacksForSideNumerical({items:rightItems,rows:rows,mainAxis:mainAxis,crossAxis:crossAxisRight,color:color,widthScale: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

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

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=_ref=>{var _tab$domain2;let{mainAxisDomain:mainAxisDomain,crossAxisLeftDomain:crossAxisLeftDomain,crossAxisRightDomain:crossAxisRightDomain,width:width,height:height,margin:margin,crossAxisLeftTicks:crossAxisLeftTicks,crossAxisLeftTickFormat:crossAxisLeftTickFormat,crossAxisRightTicks:crossAxisRightTicks,crossAxisRightTickFormat:crossAxisRightTickFormat,mainAxisTicks:mainAxisTicks,mainAxisTickFormat:mainAxisTickFormat,hasLeft:hasLeft,hasRight:hasRight,tab:tab,children:children}=_ref;const innerWidth=width-margin.left-margin.right,innerHeight=height-margin.top-margin.bottom,mainAxis=useMemo(()=>{var _tab$domain;return(null===(_tab$domain=tab.domain)||void 0===_tab$domain?void 0:_tab$domain.binding)===DOMAIN_NUMERICAL?d3.scaleLinear().domain(mainAxisDomain).range([0,innerWidth]).nice():d3.scaleBand().domain(mainAxisDomain).range([0,innerWidth]).padding(.1)},[mainAxisDomain,innerWidth,null===(_tab$domain2=tab.domain)||void 0===_tab$domain2?void 0:_tab$domain2.binding]),crossAxisLeft=useMemo(()=>d3.scaleLinear().domain(crossAxisLeftDomain).range([innerHeight,0]).nice(),[crossAxisLeftDomain,innerHeight]),crossAxisRight=useMemo(()=>d3.scaleLinear().domain(crossAxisRightDomain).range([innerHeight,0]).nice(),[crossAxisRightDomain,innerHeight]),mainAxisRef=useRef(null),crossAxisLeftRef=useRef(null),crossAxisRightRef=useRef(null),gridRef=useRef(null);return 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,crossAxisTicks=hasLeft?crossAxisLeftTicks:crossAxisRightTicks,g=d3.select(gridRef.current);if(g.selectAll("*").remove(),!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",.5).attr("stroke-dasharray","5 5"),g.select(".domain").remove()},[crossAxisLeft,crossAxisRight,innerWidth,crossAxisLeftTicks,crossAxisRightTicks]),React.createElement("svg",{width:width,height:height},React.createElement("g",{transform:"translate(".concat(margin.left,",").concat(margin.top,")")},React.createElement("g",{ref:gridRef,className:"y-grid"}),hasLeft&&React.createElement("g",{ref:crossAxisLeftRef,className:"y-axis-left"}),hasRight&&React.createElement("g",{ref:crossAxisRightRef,className:"y-axis-right",transform:"translate(".concat(innerWidth,", 0)")}),React.createElement("g",{ref:mainAxisRef,className:"x-axis",transform:"translate(0, ".concat(innerHeight,")")}),children({mainAxis:mainAxis,crossAxisLeft:crossAxisLeft,crossAxisRight: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

@@ -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=_ref=>{let{tab:tab,dataset:dataset,mainAxis:mainAxis,crossAxisLeft:crossAxisLeft,crossAxisRight:crossAxisRight,mainAxisDomain:mainAxisDomain,color:color}=_ref;const valuesByCategory=useMemo(()=>getValuesMapByCategory(dataset),[dataset]),rows=useMemo(()=>getRowList(dataset),[dataset]),splitLineClusters=useMemo(()=>getClusters(tab,LINE_TYPE),[tab]),renderStacksForSide=useMemo(()=>tab.domain.binding===DOMAIN_CATEGORICAL?renderStacksForSideCategorical:renderStacksForSideNumerical,[tab.domain.binding]);return React.createElement("g",null,splitLineClusters.map(_ref2=>{let{leftItems:leftItems,rightItems:rightItems}=_ref2;return React.createElement("g",null,renderStacksForSide({items:leftItems,rows:rows,valuesByCategory:valuesByCategory,mainAxis:mainAxis,mainAxisDomain:mainAxisDomain,crossAxis:crossAxisLeft,color:color}),renderStacksForSide({items:rightItems,rows:rows,valuesByCategory:valuesByCategory,mainAxis:mainAxis,mainAxisDomain:mainAxisDomain,crossAxis:crossAxisRight,color: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

@@ -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=_ref=>{let{items:items,valuesByCategory:valuesByCategory,mainAxis:mainAxis,mainAxisDomain:mainAxisDomain,crossAxis:crossAxis,color:color}=_ref;const codes=items.map(_ref2=>{let{rangeCode:rangeCode}=_ref2;return rangeCode}),rows=mainAxisDomain.map(category=>{const valuesByCode=valuesByCategory.get(category),row={};return codes.forEach(code=>row[code]=valuesByCode[code]),row});return d3.stack().keys(codes).offset(d3.stackOffsetDiverging)(rows).map(series=>{const code=series.key,points=series.map((_ref3,i)=>{var _mainAxis$bandwidth,_mainAxis$bandwidth2;let[y0,y1]=_ref3;return{y:Math.max(y0,y1),x:mainAxis(mainAxisDomain[i])+(null!==(_mainAxis$bandwidth=null===(_mainAxis$bandwidth2=mainAxis.bandwidth)||void 0===_mainAxis$bandwidth2?void 0:_mainAxis$bandwidth2.call(mainAxis))&&void 0!==_mainAxis$bandwidth?_mainAxis$bandwidth:0)/2}}),path=d3.line().defined(d=>Number.isFinite(d.y)).x(d=>d.x).y(d=>crossAxis(d.y))(points);return path?React.createElement("path",{key:code,d:path,fill:"none",stroke:color(code),strokeWidth:2,strokeLinejoin:"round",strokeLinecap:"round"}):null})};export const renderStacksForSideNumerical=_ref4=>{let{items:items,rows:rows,mainAxis:mainAxis,crossAxis:crossAxis,color:color}=_ref4;return items.map(_ref5=>{let{rangeCode:rangeCode,domainCode:domainCode}=_ref5;if(!domainCode)return null;const points=rows.map(r=>{const xVal=r[domainCode],yVal=r[rangeCode];return Number.isFinite(xVal)&&Number.isFinite(yVal)?{x:mainAxis(xVal),y:crossAxis(yVal)}:null}).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);return path?React.createElement("path",{key:"num-".concat(rangeCode,"-").concat(domainCode),d:path,fill:"none",stroke:color(rangeCode),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=_ref=>{let{tab:tab,dataset:dataset,mainAxis:mainAxis,mainAxisDomain:mainAxisDomain,crossAxisLeft:crossAxisLeft,crossAxisRight:crossAxisRight,color:color}=_ref;const valuesByCategory=useMemo(()=>getValuesMapByCategory(dataset),[dataset]),rows=useMemo(()=>getRowList(dataset),[dataset]),splitPointClusters=useMemo(()=>getClusters(tab,POINT_TYPE),[tab]),sizeExtent=useMemo(()=>getSizeExtent({tab:tab,splitPointClusters:splitPointClusters,valuesByCategory:valuesByCategory,mainAxisDomain:mainAxisDomain,rows:rows}),[splitPointClusters,mainAxisDomain,valuesByCategory,rows]),sizeScale=useMemo(()=>sizeExtent?d3.scaleSqrt().domain(sizeExtent).range([MIN_RADIUS,MAX_RADIUS]).clamp(!0):null,[sizeExtent]),renderPointsForSide=useMemo(()=>tab.domain.binding===DOMAIN_CATEGORICAL?renderPointsForSideCategorical:renderPointsForSideNumerical,[tab.domain.binding]);return React.createElement("g",null,splitPointClusters.map(_ref2=>{let{leftItems:leftItems,rightItems:rightItems}=_ref2;return React.createElement("g",null,renderPointsForSide({items:leftItems,valuesByCategory:valuesByCategory,mainAxis:mainAxis,mainAxisDomain:mainAxisDomain,crossAxis:crossAxisLeft,color:color,sizeScale:sizeScale,rows:rows}),renderPointsForSide({items:rightItems,valuesByCategory:valuesByCategory,mainAxis:mainAxis,mainAxisDomain:mainAxisDomain,crossAxis:crossAxisRight,color:color,sizeScale:sizeScale,rows: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

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