evui 3.3.8 → 3.3.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evui",
-  "version": "3.3.8",
+  "version": "3.3.11",
   "description": "A EXEM Library project",
   "author": "exem <dev_client@ex-em.com>",
   "license": "MIT",

package/src/components/chart/Chart.vue

@@ -20,6 +20,10 @@ import { onMounted, onBeforeUnmount, watch, onDeactivated } from 'vue';
         type: Object,
         default: null,
       },
+      selectedLabel: {
+        type: Object,
+        default: null,
+      },
       options: {
         type: Object,
         default: () => ({}),
@@ -38,6 +42,7 @@ import { onMounted, onBeforeUnmount, watch, onDeactivated } from 'vue';
       'dbl-click',
       'drag-select',
       'update:selectedItem',
+      'update:selectedLabel',
     ],
     setup(props) {
       let evChart = {};
@@ -45,7 +50,8 @@ import { onMounted, onBeforeUnmount, watch, onDeactivated } from 'vue';
 
       const {
         eventListeners,
-        selectInfo,
+        selectItemInfo,
+        selectLabelInfo,
         getNormalizedData,
         getNormalizedOptions,
       } = useModel();
@@ -66,7 +72,8 @@ import { onMounted, onBeforeUnmount, watch, onDeactivated } from 'vue';
           normalizedData,
           normalizedOptions,
           eventListeners,
-          selectInfo,
+          selectItemInfo,
+          selectLabelInfo,
         );
       };
 
@@ -102,13 +109,15 @@ import { onMounted, onBeforeUnmount, watch, onDeactivated } from 'vue';
         }, { deep: true });
 
         await watch(() => props.selectedItem, (newValue) => {
-          if (!newValue?.seriesID) {
-            return;
-          }
-
           const chartType = props.options?.type;
           evChart.selectItemByData(newValue, chartType);
         }, { deep: true });
+
+        await watch(() => props.selectedLabel, (newValue) => {
+          if (newValue.dataIndex) {
+            evChart.renderWithSelectLabel(newValue.dataIndex);
+          }
+        }, { deep: true });
       });
 
       onBeforeUnmount(() => {

package/src/components/chart/chart.core.js

@@ -14,7 +14,7 @@ import Pie from './plugins/plugins.pie';
 import Tip from './element/element.tip';
 
 class EvChart {
-  constructor(target, data, options, listeners, defaultSelectInfo) {
+  constructor(target, data, options, listeners, defaultSelectItemInfo, defaultSelectLabelInfo) {
     Object.keys(Model).forEach(key => Object.assign(this, Model[key]));
     Object.assign(this, Title);
     Object.assign(this, Legend);
@@ -61,11 +61,12 @@ class EvChart {
     this.seriesList = {};
     this.lastTip = { pos: null, value: null };
     this.seriesInfo = {
-      charts: { pie: [], bar: [], line: [], scatter: [] },
+      charts: { pie: [], bar: [], line: [], scatter: [], heatMap: [] },
       count: 0,
     };
 
-    this.defaultSelectInfo = defaultSelectInfo;
+    this.defaultSelectItemInfo = defaultSelectItemInfo;
+    this.defaultSelectLabelInfo = defaultSelectLabelInfo;
   }
 
   /**
@@ -92,6 +93,7 @@ class EvChart {
 
     this.axesRange = this.getAxesRange();
     this.labelOffset = this.getLabelOffset();
+    this.initSelectedLabelInfo();
 
     this.drawChart();
 
@@ -146,11 +148,12 @@ class EvChart {
 
   /**
    * Draw each series
+   * @param {any} [hitInfo=undefined]    from mousemove callback (object or undefined)
    *
    * @returns {undefined}
    */
   drawSeries(hitInfo) {
-    const maxTip = this.options.maxTip;
+    const { maxTip, selectLabel, selectItem } = this.options;
 
     const opt = {
       ctx: this.bufferCtx,
@@ -158,6 +161,7 @@ class EvChart {
       labelOffset: this.labelOffset,
       axesSteps: this.axesSteps,
       maxTipOpt: { background: maxTip.background, color: maxTip.color },
+      selectLabel: { option: selectLabel, selected: this.defaultSelectLabelInfo },
     };
 
     let showIndex = 0;
@@ -177,37 +181,76 @@ class EvChart {
       for (let jx = 0; jx < chartTypeSet.length; jx++) {
         const series = this.seriesList[chartTypeSet[jx]];
 
-        if (chartType === 'line' || chartType === 'scatter') {
-          series.draw(opt);
-        } else if (chartType === 'bar') {
-          const { thickness, borderRadius } = this.options;
-          series.draw({ thickness, borderRadius, showSeriesCount, showIndex, ...opt });
-
-          if (series.show) {
-            showIndex++;
+        switch (chartType) {
+          case 'line':
+          case 'heatMap': {
+            series.draw(opt);
+            break;
           }
-        } else {
-          const selectInfo = hitInfo
-            ?? this.lastHitInfo
-            ?? { sId: this.defaultSelectInfo?.seriesID };
-
-          if (this.options.sunburst) {
-            this.drawSunburst(selectInfo);
-          } else {
-            this.drawPie(selectInfo);
+          case 'bar': {
+            const { thickness, borderRadius } = this.options;
+            series.draw({ thickness, borderRadius, showSeriesCount, showIndex, ...opt });
+            if (series.show) {
+              showIndex++;
+            }
+            break;
           }
-
-          if (this.options.doughnutHoleSize > 0) {
-            this.drawDoughnutHole();
+          case 'pie': {
+            const selectInfo = hitInfo
+              ?? this.lastHitInfo
+              ?? { sId: this.defaultSelectItemInfo?.seriesID };
+
+            if (this.options.sunburst) {
+              this.drawSunburst(selectInfo);
+            } else {
+              this.drawPie(selectInfo);
+            }
+
+            if (this.options.doughnutHoleSize > 0) {
+              this.drawDoughnutHole();
+            }
+            break;
+          }
+          case 'scatter': {
+            if (selectItem.use && selectItem.useSeriesOpacity) {
+              if (hitInfo) {
+                if (hitInfo?.maxIndex || hitInfo?.maxIndex === 0) {
+                  opt.selectInfo = {
+                    seriesID: hitInfo.sId,
+                    dataIndex: hitInfo.maxIndex,
+                  };
+                } else {
+                  opt.selectInfo = null;
+                }
+              } else if (this.lastHitInfo?.maxIndex || this.lastHitInfo?.maxIndex === 0) {
+                opt.selectInfo = {
+                  seriesID: this.lastHitInfo.sId,
+                  dataIndex: this.lastHitInfo.maxIndex,
+                };
+              } else if (this.defaultSelectItemInfo?.dataIndex
+                || this.defaultSelectItemInfo?.dataIndex === 0) {
+                opt.selectInfo = {
+                  seriesID: this.defaultSelectItemInfo.seriesID,
+                  dataIndex: this.defaultSelectItemInfo.dataIndex,
+                };
+              } else {
+                opt.selectInfo = null;
+              }
+            }
+
+            series.draw(opt);
+            break;
+          }
+          default: {
+            break;
           }
-          break;
         }
       }
     }
   }
 
   /**
-   * Draw Tip with hitInfo and defaultSelectInfo
+   * Draw Tip with hitInfo and defaultSelectItemInfo
    * @param hitInfo
    */
   drawTip(hitInfo) {
@@ -221,8 +264,8 @@ class EvChart {
       tipLocationInfo = hitInfo;
     } else if (this.lastHitInfo) {
       tipLocationInfo = this.lastHitInfo;
-    } else if (this.defaultSelectInfo) {
-      tipLocationInfo = this.getItem(this.defaultSelectInfo, false);
+    } else if (this.defaultSelectItemInfo) {
+      tipLocationInfo = this.getItem(this.defaultSelectItemInfo, false);
     } else {
       tipLocationInfo = null;
     }
@@ -281,11 +324,21 @@ class EvChart {
    */
   drawAxis(hitInfo) {
     this.axesX.forEach((axis, index) => {
-      axis.draw(this.chartRect, this.labelOffset, this.axesSteps.x[index], hitInfo);
+      axis.draw(
+        this.chartRect,
+        this.labelOffset,
+        this.axesSteps.x[index],
+        hitInfo,
+        this.defaultSelectLabelInfo);
     });
 
     this.axesY.forEach((axis, index) => {
-      axis.draw(this.chartRect, this.labelOffset, this.axesSteps.y[index]);
+      axis.draw(
+        this.chartRect,
+        this.labelOffset,
+        this.axesSteps.y[index],
+        hitInfo,
+        this.defaultSelectLabelInfo);
     });
   }
 
@@ -545,6 +598,7 @@ class EvChart {
           bar: [],
           line: [],
           scatter: [],
+          heatMap: [],
         },
         count: 0,
       };
@@ -604,8 +658,9 @@ class EvChart {
     this.axesY = this.createAxes('y', options.axesY);
     this.axesRange = this.getAxesRange();
     this.labelOffset = this.getLabelOffset();
+    this.initSelectedLabelInfo();
 
-    this.render();
+    this.render(updateInfo?.hitInfo);
 
     const isDragMove = this.dragInfo && this.drawSelectionArea;
     if (isDragMove) {

package/src/components/chart/element/element.bar.js

@@ -131,7 +131,13 @@ class Bar {
       }
 
       const barColor = item.dataColor || this.color;
-      const isDownplay = this.state === 'downplay';
+
+      const selectLabelOption = param.selectLabel.option;
+      const selectedLabel = param.selectLabel.selected ?? { dataIndex: [] };
+
+      const isDownplay = selectLabelOption.use && selectLabelOption.useSeriesOpacity
+          ? selectedLabel.dataIndex.length && !selectedLabel.dataIndex.includes(index)
+          : this.state === 'downplay';
 
       if (typeof barColor !== 'string') {
         ctx.fillStyle = Canvas.createGradient(
@@ -332,7 +338,7 @@ class Bar {
    */
   drawValueLabels({ context, data, positions, isHighlight }) {
     const isHorizontal = this.isHorizontal;
-    const { fontSize, textColor, align, formatter } = this.showValue;
+    const { fontSize, textColor, align, formatter, decimalPoint } = this.showValue;
     const { x, y, w, h } = positions;
     const ctx = context;
 
@@ -361,7 +367,7 @@ class Bar {
     }
 
     if (!formatter || typeof formattedTxt !== 'string') {
-      formattedTxt = Util.labelSignFormat(value);
+      formattedTxt = Util.labelSignFormat(value, decimalPoint);
     }
 
     const vw = Math.round(ctx.measureText(formattedTxt).width);

package/src/components/chart/element/element.heatmap.js

@@ -0,0 +1,213 @@
+import { merge } from 'lodash-es';
+import Canvas from '../helpers/helpers.canvas';
+import Util from '../helpers/helpers.util';
+import { COLOR, HEAT_MAP_OPTION } from '../helpers/helpers.constant';
+
+class HeatMap {
+  constructor(sId, opt, sIdx) {
+    const merged = merge({}, HEAT_MAP_OPTION, opt);
+      Object.keys(merged).forEach((key) => {
+        this[key] = merged[key];
+    });
+
+    ['color', 'pointFill', 'fillColor'].forEach((colorProp) => {
+      if (this[colorProp] === undefined) {
+        this[colorProp] = COLOR[sIdx];
+      }
+    });
+
+    this.colorAxis = this.createColorAxis(opt.colorOpt);
+    this.errorColor = opt.colorOpt.error;
+    this.borderColor = opt.colorOpt.border;
+
+    this.sId = sId;
+    this.data = [];
+    this.spaces = opt.spaces || { x: null, y: null };
+    this.size = {
+      w: 0,
+      h: 0,
+    };
+    this.valueOpt = {
+      max: 0,
+      interval: 0,
+    };
+    this.type = 'heatMap';
+  }
+
+  /**
+   * create series color axis
+   * @param colorOpt
+   * @returns {*[]}
+   */
+  createColorAxis(colorOpt) {
+    const colorAxis = [];
+    const { min, max, categoryCnt } = colorOpt;
+
+    const minColor = min.includes('#') ? Util.hexToRgb(min) : min;
+    const maxColor = max.includes('#') ? Util.hexToRgb(max) : max;
+
+    const [minR, minG, minB] = minColor.split(',');
+    const [maxR, maxG, maxB] = maxColor.split(',');
+
+    const unitR = Math.floor((minR - maxR) / (categoryCnt - 1));
+    const unitG = Math.floor((minG - maxG) / (categoryCnt - 1));
+    const unitB = Math.floor((minB - maxB) / (categoryCnt - 1));
+
+    for (let ix = 0; ix < categoryCnt; ix++) {
+       const r = +minR - (unitR * ix);
+       const g = +minG - (unitG * ix);
+       const b = +minB - (unitB * ix);
+
+       colorAxis.push({
+         id: `color#${ix}`,
+         value: `rgb(${r},${g},${b})`,
+         state: 'normal',
+         show: true,
+       });
+    }
+
+    return colorAxis;
+  }
+
+  getColorIndex(value) {
+    const existError = this.valueOpt.existError;
+    const maxIndex = this.colorAxis.length;
+    if (value < 0) {
+      return maxIndex - 1;
+    }
+
+    const colorIndex = Math.floor(value / this.valueOpt.interval);
+    if (colorIndex >= maxIndex) {
+      return existError ? maxIndex - 2 : maxIndex - 1;
+    }
+
+    return colorIndex;
+  }
+
+  drawItem(ctx, xp, yp) {
+    ctx.beginPath();
+    ctx.strokeRect(xp - this.size.w, yp + Math.SQRT2, this.size.w, this.size.h);
+    ctx.fillRect(xp - this.size.w, yp + Math.SQRT2, this.size.w, this.size.h);
+    ctx.closePath();
+    ctx.stroke();
+  }
+
+  draw(param) {
+    if (!this.show) {
+      return;
+    }
+
+    const { ctx, chartRect, labelOffset, axesSteps } = param;
+
+    const minmaxX = axesSteps.x[this.xAxisIndex];
+    const minmaxY = axesSteps.y[this.yAxisIndex];
+
+    const xArea = chartRect.chartWidth - (labelOffset.left + labelOffset.right);
+    const yArea = chartRect.chartHeight - (labelOffset.top + labelOffset.bottom);
+
+    const xsp = chartRect.x1 + labelOffset.left;
+    const ysp = chartRect.y2 - labelOffset.bottom;
+
+    this.size.w = Math.floor(xArea / (this.spaces.x || (minmaxX.graphMax - minmaxX.graphMin)));
+    this.size.h = Math.floor(yArea / (this.spaces.y || (minmaxY.graphMax - minmaxY.graphMin)));
+
+    this.data.forEach((item) => {
+      item.xp = Canvas.calculateX(item.x, minmaxX.graphMin, minmaxX.graphMax, xArea, xsp);
+      item.yp = Canvas.calculateY(item.y, minmaxY.graphMin, minmaxY.graphMax, yArea, ysp);
+
+      const { xp, yp, o: value } = item;
+
+      if (xp !== null && yp !== null) {
+        const colorIndex = this.getColorIndex(value);
+        const opacity = this.colorAxis[colorIndex].state === 'downplay' ? 0.1 : 1;
+        item.dataColor = value < 0 ? this.errorColor : this.colorAxis[colorIndex].value;
+        item.cId = this.colorAxis[colorIndex].id;
+        if (this.colorAxis[colorIndex].show) {
+          ctx.strokeStyle = Util.colorStringToRgba(this.borderColor, opacity);
+          ctx.fillStyle = Util.colorStringToRgba(item.dataColor, opacity);
+          this.drawItem(ctx, xp, yp);
+        }
+      }
+    });
+  }
+
+  /**
+   *Returns items in range
+   * @param {object} params  range values
+   *
+   * @returns {array}
+   */
+  findItems({ xsp, ysp, width, height }) {
+    const gdata = this.data;
+    const xep = xsp + width;
+    const yep = ysp + height;
+    return gdata.filter(seriesData =>
+      (xsp - 1 <= seriesData.xp && seriesData.xp <= xep + 1
+        && ysp - 1 <= seriesData.yp && seriesData.yp <= yep + 1));
+  }
+
+  /**
+   * Draw item highlight
+   * @param {object}   item       object for drawing series data
+   * @param {object}   context    canvas context
+   *
+   * @returns {undefined}
+   */
+  itemHighlight(item, context) {
+    const gdata = item.data;
+    const ctx = context;
+
+    const x = gdata.xp;
+    const y = gdata.yp;
+
+    ctx.save();
+    if (x !== null && y !== null) {
+      const color = gdata.dataColor;
+      ctx.strokeStyle = Util.colorStringToRgba(color, 1);
+      ctx.fillStyle = Util.colorStringToRgba(color, this.highlight.maxShadowOpacity);
+      this.drawItem(ctx, x, y);
+    }
+
+    ctx.restore();
+  }
+
+  /**
+   * Find graph item for tooltip
+   * @param {array}  offset       mouse position
+   *
+   * @returns {object} graph item
+   */
+  findGraphData(offset) {
+    const xp = offset[0];
+    const yp = offset[1];
+    const item = {
+      data: null,
+      hit: false,
+      color: null,
+      name: null,
+    };
+    const wSize = this.size.w;
+    const hSize = this.size.h;
+    const gdata = this.data;
+
+    const foundItem = gdata.find((data) => {
+      const x = data.xp;
+      const y = data.yp;
+
+      return (x - wSize <= xp)
+        && (xp <= x)
+        && (y <= yp)
+        && (yp <= y + hSize);
+    });
+
+    if (foundItem) {
+      item.data = foundItem;
+      item.color = foundItem.dataColor;
+      item.hit = true;
+    }
+
+    return item;
+  }
+}
+
+export default HeatMap;

package/src/components/chart/element/element.pie.js

@@ -24,9 +24,9 @@ class Pie {
     this.centerX = 0;
     this.centerY = 0;
     this.radius = 0;
+    this.doughnutHoleSize = 0;
     this.startAngle = 0;
     this.endAngle = 0;
-    this.slice = null;
     this.state = null;
     this.ctx = null;
     this.isSelect = false;
@@ -45,6 +45,7 @@ class Pie {
     const slice = new Path2D();
 
     const radius = this.isSelect ? this.radius + 5 : this.radius;
+    const doughnutHoleRadius = this.radius * this.doughnutHoleSize;
 
     const color = this.color;
     const noneDownplayOpacity = color.includes('rgba') ? Util.getOpacity(color) : 1;
@@ -64,9 +65,11 @@ class Pie {
       ctx.stroke(slice);
     }
 
-    ctx.closePath();
+    if (this.showValue?.use) {
+      this.drawValueLabels(ctx, doughnutHoleRadius);
+    }
 
-    this.slice = slice;
+    ctx.closePath();
     this.ctx = ctx;
   }
 
@@ -78,8 +81,19 @@ class Pie {
    */
   findGraphData([offsetX, offsetY]) {
     const item = { data: null, hit: false, color: null, index: -1 };
-
-    if (this.show && this.ctx?.isPointInPath(this.slice, offsetX, offsetY)) {
+    const {
+      radius,
+      startAngle,
+      endAngle,
+      centerX,
+      centerY,
+    } = this;
+
+    const distance = Math.sqrt((offsetX - centerX) ** 2 + (offsetY - centerY) ** 2);
+    const radian = (2.5 * Math.PI) - Math.atan2((offsetX - centerX), (offsetY - centerY));
+    const isPointInPath = radius > distance && radian >= startAngle && radian <= endAngle;
+
+    if (this.show && isPointInPath) {
       item.type = this.type;
       item.data = this.data;
       item.hit = true;
@@ -101,6 +115,7 @@ class Pie {
   itemHighlight(item, context) {
     const ctx = context;
     const radius = this.isSelect ? this.radius + 5 : this.radius;
+    const doughnutHoleRadius = this.radius * this.doughnutHoleSize;
 
     ctx.save();
     ctx.shadowOffsetX = 0;
@@ -116,7 +131,62 @@ class Pie {
     ctx.arc(this.centerX, this.centerY, radius, this.startAngle, this.endAngle);
     ctx.lineTo(this.centerX, this.centerY);
     ctx.fill();
+
+    if (this.showValue?.use) {
+      this.drawValueLabels(ctx, doughnutHoleRadius);
+    }
+
     ctx.closePath();
+    ctx.restore();
+  }
+
+  /**
+   * Draw value label if series 'use' of showValue option is true
+   *
+   * @param context           canvas context
+   */
+  drawValueLabels(context) {
+    const { fontSize, textColor, formatter } = this.showValue;
+    const ctx = context;
+
+    ctx.save();
+    ctx.beginPath();
+
+    ctx.font = `normal normal normal ${fontSize}px Roboto`;
+    ctx.fillStyle = textColor;
+    ctx.lineWidth = 1;
+    ctx.textAlign = 'center';
+    ctx.textBaseline = 'middle';
+
+    const value = this.data.o;
+
+    let formattedTxt;
+    if (formatter) {
+      formattedTxt = formatter(value);
+    }
+
+    if (!formatter || typeof formattedTxt !== 'string') {
+      formattedTxt = Util.labelSignFormat(value);
+    }
+
+    const ratio = 1.8;
+    const radius = this.radius - this.doughnutHoleSize;
+    const innerAngle = ((this.endAngle - this.startAngle) * 180) / Math.PI;
+    const valueHeight = fontSize + 4;
+    const valueWidth = Math.round(ctx.measureText(formattedTxt).width);
+
+    if (innerAngle >= valueWidth * ratio
+      && innerAngle >= valueHeight * ratio
+      && radius >= valueWidth * ratio
+      && radius >= valueHeight * ratio
+    ) {
+      const halfRadius = (radius / 2) + this.doughnutHoleSize;
+      const centerAngle = ((this.endAngle - this.startAngle) / 2) + this.startAngle;
+      const xPos = halfRadius * Math.cos(centerAngle) + this.centerX;
+      const yPos = halfRadius * Math.sin(centerAngle) + this.centerY;
+
+      ctx.fillText(formattedTxt, xPos, yPos);
+    }
 
     ctx.restore();
   }