evui 3.4.129 → 3.4.130

package/src/components/chart/helpers/helpers.util.js

@@ -160,29 +160,25 @@ export default {
       return value;
     }
 
-    const isNegative = value < 0;
-    const absValue = Math.abs(value);
-
     const assignLabelWith = (v, target, lb) => {
-      const result = v % target === 0
-        ? `${(v / target).toFixed(decimalPoint)}${lb}`
-        : `${(v / target).toFixed(1)}${lb}`;
-
-      return isNegative ? `-${result}` : result;
+      if (v % target === 0) {
+        return `${(v / target).toFixed(decimalPoint)}${lb}`;
+      }
+      return `${(v / target).toFixed(1)}${lb}`;
     };
 
-    if (absValue >= quad) {
-      label = assignLabelWith(absValue, quad, 'P');
-    } else if (absValue >= trill) {
-      label = assignLabelWith(absValue, trill, 'T');
-    } else if (absValue >= billi) {
-      label = assignLabelWith(absValue, billi, 'G');
-    } else if (absValue >= milli) {
-      label = assignLabelWith(absValue, milli, 'M');
-    } else if (absValue >= killo) {
-      label = assignLabelWith(absValue, 1000, 'K');
+    if (value >= quad) {
+      label = assignLabelWith(value, quad, 'P');
+    } else if (value >= trill) {
+      label = assignLabelWith(value, trill, 'T');
+    } else if (value >= billi) {
+      label = assignLabelWith(value, billi, 'G');
+    } else if (value >= milli) {
+      label = assignLabelWith(value, milli, 'M');
+    } else if (value >= killo) {
+      label = assignLabelWith(value, 1000, 'K');
     } else {
-      label = isNegative ? `-${absValue.toFixed(decimalPoint)}` : value.toFixed(decimalPoint);
+      label = value.toFixed(decimalPoint);
     }
 
     return label;

package/src/components/chart/model/model.store.js

@@ -25,23 +25,21 @@ const modules = {
           seriesIDs.forEach((seriesID) => {
             const series = this.seriesList[seriesID];
             const sData = data[seriesID];
-            const passingValue = series?.passingValue;
 
             if (series && sData) {
               series.data = this.addSeriesDSforScatter(sData);
-              series.minMax = this.getSeriesMinMax(series.data, passingValue);
+              series.minMax = this.getSeriesMinMax(series.data);
             }
           });
         } else if (typeKey === 'heatMap') {
           seriesIDs.forEach((seriesID) => {
             const series = this.seriesList[seriesID];
-            const passingValue = series?.passingValue;
             const sData = data[seriesID];
 
             if (series && sData) {
               series.labels = label;
               series.data = this.addSeriesDSForHeatMap(sData);
-              series.minMax = this.getSeriesMinMax(series.data, passingValue);
+              series.minMax = this.getSeriesMinMax(series.data);
               series.valueOpt = this.getSeriesValueOptForHeatMap(series);
             }
           });
@@ -70,7 +68,7 @@ const modules = {
               } else {
                 series.data = this.addSeriesDS(sData, label, series.isExistGrp);
               }
-              series.minMax = this.getSeriesMinMax(series.data, series.passingValue);
+              series.minMax = this.getSeriesMinMax(series.data);
             }
           });
         }
@@ -410,21 +408,17 @@ const modules = {
     const isHorizontal = this.options.horizontal;
     const sdata = [];
 
-    const getBaseDataPosition = (baseIndex, dataIndex, curr) => {
+    const getBaseDataPosition = (baseIndex, dataIndex) => {
       const nextBaseSeriesIndex = baseIndex - 1;
       const baseSeries = this.seriesList[bsIds[baseIndex]];
       const baseDataList = baseSeries.data;
       const baseData = baseDataList[dataIndex];
       const position = isHorizontal ? baseData?.x : baseData?.y;
+      const isPassingValue = baseSeries.passingValue === baseData?.o;
 
-      const baseValue = baseData?.o;
-      const isPassingValue = !Util.isNullOrUndefined(baseSeries?.passingValue)
-      && baseSeries?.passingValue === baseValue;
-      const isSameSign = (curr >= 0 && baseValue >= 0) || (curr < 0 && baseValue < 0);
-
-      if (isPassingValue || position == null || !isSameSign || !baseSeries.show) {
+      if (isPassingValue || position == null || !baseSeries.show) {
         if (nextBaseSeriesIndex > -1) {
-          return getBaseDataPosition(nextBaseSeriesIndex, dataIndex, curr);
+          return getBaseDataPosition(nextBaseSeriesIndex, dataIndex);
         }
 
         return 0;
@@ -435,7 +429,7 @@ const modules = {
 
     data.forEach((curr, index) => {
       const baseIndex = bsIds.length - 1 < 0 ? 0 : bsIds.length - 1;
-      let bdata = getBaseDataPosition(baseIndex, index, curr); // base(previous) series data
+      let bdata = getBaseDataPosition(baseIndex, index); // base(previous) series data
       let odata = curr; // current series original data
       let ldata = label[index]; // label data
       let gdata = curr; // current series data which added previous series's value
@@ -588,34 +582,30 @@ const modules = {
     return data;
   },
 
+
   /**
    * Take series data to create min/max info for each series
    * @param {object}  data    series data
    *
    * @returns {object} min/max info for series
    */
-  getSeriesMinMax(data, passingValue) {
+  getSeriesMinMax(data) {
     const def = { minX: null, minY: null, maxX: null, maxY: null, maxDomain: null };
     const isHorizontal = this.options.horizontal;
 
     if (data.length) {
-      const usePassingValue = !Util.isNullOrUndefined(passingValue);
-
       return data.reduce((acc, p, index) => {
         const minmax = acc;
         const px = p.x?.value || p.x;
         const py = p.y?.value || p.y;
-        const po = p.o?.value || p.o;
 
-        if ((usePassingValue ? (po !== passingValue && px <= minmax.minX) : px <= minmax.minX)) {
+        if (px <= minmax.minX) {
           minmax.minX = (px === null) ? 0 : px;
         }
-
-        if ((usePassingValue ? (po !== passingValue && py <= minmax.minY) : py <= minmax.minY)) {
+        if (py <= minmax.minY) {
           minmax.minY = (py === null) ? 0 : py;
         }
-
-        if ((usePassingValue ? (po !== passingValue && px >= minmax.maxX) : px >= minmax.maxX)) {
+        if (px >= minmax.maxX) {
           minmax.maxX = (px === null) ? 0 : px;
 
           if (isHorizontal && px !== null) {
@@ -623,8 +613,7 @@ const modules = {
             minmax.maxDomainIndex = index;
           }
         }
-
-        if ((usePassingValue ? (po !== passingValue && py >= minmax.maxY) : py >= minmax.maxY)) {
+        if (py >= minmax.maxY) {
           minmax.maxY = (py === null) ? 0 : py;
 
           if (!isHorizontal && py !== null) {
@@ -1267,25 +1256,13 @@ const modules = {
               minmax.y[axisY].min = smm.minY;
             }
           }
-
-          const isExistGrp = this.seriesList[key].isExistGrp;
-          const maxXisNegative = minmax.x[axisX].max < 0;
-
-          if (isExistGrp && maxXisNegative) {
-            minmax.x[axisX].max = smm.maxX;
-            minmax.x[axisX].maxSID = key;
-          } else if (!minmax.x[axisX].max || smm.maxX >= minmax.x[axisX].max) {
+          if (smm.maxX >= minmax.x[axisX].max) {
             minmax.x[axisX].max = smm.maxX;
             minmax.x[axisX].maxSID = key;
           }
-
-          const maxYisNegative = minmax.y[axisY].max < 0;
-          if (isExistGrp && maxYisNegative) {
-            minmax.y[axisY].max = smm.maxY;
-            minmax.y[axisY].maxSID = key;
-          } else if (!minmax.y[axisY].max || smm.maxY >= minmax.y[axisY].max) {
+          if (smm.maxY >= minmax.y[axisY].max) {
             minmax.y[axisY].max = smm.maxY;
-            minmax.y[axisY].maxSID = key;
+            minmax.y[axisX].maxSID = key;
           }
         }
 

package/src/components/chart/plugins/plugins.interaction.js

@@ -79,29 +79,12 @@ const modules = {
       }
 
       if (indicator.use && type !== 'pie' && type !== 'scatter' && type !== 'heatMap') {
-        // Use data point position instead of mouse position for indicator when tooltip is enabled
-        let indicatorOffset = offset;
-        let label = this.getTimeLabel(offset);
-        const useAxisTrigger = tooltip.use && tooltip.trigger === 'axis' && type === 'line';
-
-        if (useAxisTrigger && Object.keys(hitInfo.items).length) {
-          const hitId = hitInfo.hitId || Object.keys(hitInfo.items)[0];
-          const hitItem = hitInfo.items[hitId];
-
-          if (hitItem && hitItem.data && hitItem.data.xp !== undefined
-            && hitItem.data.yp !== undefined) {
-            indicatorOffset = [hitItem.data.xp, hitItem.data.yp];
-            label = this.data.labels[hitItem.index];
-          }
-        }
-
-        this.drawIndicator(indicatorOffset, indicator.color);
-
+        this.drawIndicator(offset, indicator.color);
+        const label = this.getTimeLabel(offset);
         args.hoveredLabel = {
           horizontal: this.options.horizontal,
           label,
           mousePosition: [e.clientX, e.clientY],
-          useAxisTrigger,
         };
       } else {
         args.hoveredLabel = {
@@ -879,18 +862,11 @@ const modules = {
     }
   },
 
-  /**
-   * @typedef {object} HitInfo
-   * @property {object} items
-   * @property {string} hitId
-   * @property {object} maxTip
-   * @property {object} maxHighlight
-   */
   /**
    * Find graph item on mouse position
    * @param {array} offset    return value from getMousePosition()
    *
-   * @returns {HitInfo} hit item information
+   * @returns {object} hit item information
    */
   findHitItem(offset) {
     const sIds = Object.keys(this.seriesList);
@@ -898,29 +874,6 @@ const modules = {
     const isHorizontal = !!this.options.horizontal;
     const ctx = this.tooltipCtx;
 
-    // Cache for measureText to avoid repeated calculations
-    if (!this._measureTextCache) {
-      this._measureTextCache = new Map();
-    }
-
-    // Use sliding window cache based on text length to maintain frequently used entries
-    if (this._measureTextCache.size > 1000) {
-      const entries = Array.from(this._measureTextCache.entries());
-
-      // Sort by text length (shorter texts are likely more frequently used)
-      entries.sort(([keyA], [keyB]) => {
-        const textA = keyA.split('-')[0];
-        const textB = keyB.split('-')[0];
-        return textA.length - textB.length;
-      });
-
-      // Keep the first 500 entries (shorter texts)
-      this._measureTextCache.clear();
-      entries.slice(0, 500).forEach(([key, value]) => {
-        this._measureTextCache.set(key, value);
-      });
-    }
-
     let hitId = null;
     let maxs = '';
     let maxsw = 0;
@@ -932,15 +885,10 @@ const modules = {
       const sId = sIds[ix];
       const series = this.seriesList[sId];
 
-      // Skip hidden series for performance
-      if (!series.show || !series.findGraphData) {
-        // eslint-disable-next-line no-continue
-        continue;
-      }
+      if (series.findGraphData) {
+        const item = series.findGraphData(offset, isHorizontal);
 
-      const item = series.findGraphData(offset, isHorizontal);
-
-      if (item?.data) {
+        if (item?.data) {
           let gdata;
 
           if (item.data.o === null && series.interpolation !== 'zero') {
@@ -958,17 +906,7 @@ const modules = {
               seriesName: series.name,
               itemData: item.data,
             });
-            // Use cached measureText for better performance
-            let sw = 1;
-            if (ctx) {
-              const cacheKey = `${formattedSeriesName}-${ctx.font}`;
-              if (this._measureTextCache.has(cacheKey)) {
-                sw = this._measureTextCache.get(cacheKey);
-              } else {
-                sw = ctx.measureText(formattedSeriesName).width;
-                this._measureTextCache.set(cacheKey, sw);
-              }
-            }
+            const sw = ctx ? ctx.measureText(formattedSeriesName).width : 1;
 
             item.id = series.id;
             item.name = formattedSeriesName;
@@ -1005,6 +943,7 @@ const modules = {
           }
         }
       }
+    }
 
     hitId = hitId === null ? Object.keys(items)[0] : hitId;
     const maxHighlight = maxg !== null ? [maxSID, maxg] : null;

package/src/components/chart/plugins/plugins.legend.js

@@ -183,7 +183,8 @@ const modules = {
 
     let useLegendSeries = [];
     if (groups) {
-      useLegendSeries = groups.filter(sId => this.seriesList[sId].showLegend)
+      useLegendSeries = groups.slice().reverse()
+        .filter(sId => this.seriesList[sId].showLegend)
         .map(sId => [sId, this.seriesList[sId]]);
     } else {
       useLegendSeries = Object.entries(this.seriesList)
@@ -220,8 +221,9 @@ const modules = {
     }
   },
   /**
-   * Adds legends for each group in `groups` array, iterating through each series within the group.
-   * Only adds series with `showLegend` set to `true`.
+   * Adds legends for each group in `groups` array, iterating through each series
+   * within the group in reverse order. This ensures the legends align with the series
+   * order as displayed in the chart. Only adds series with `showLegend` set to `true`.
    *
    * @param {Array} groups - Array of groups containing series identifiers.
    * @param {Object} seriesList - Object containing all series, keyed by series ID.
@@ -230,7 +232,7 @@ const modules = {
    */
   addLegendForGroups(groups, seriesList, useTable) {
     groups.forEach((group) => {
-      group.forEach((sId) => {
+      group.slice().reverse().forEach((sId) => {
         const series = seriesList[sId];
         if (series && series.showLegend) {
           this.addLegendBasedOnType(series, useTable);

package/src/components/chart/plugins/plugins.tooltip.js

@@ -1,6 +1,6 @@
 import { convertToPercent } from '@/common/utils';
 import debounce from '@/common/utils.debounce';
-import { inRange, isNil } from 'lodash-es';
+import { inRange } from 'lodash-es';
 import Canvas from '../helpers/helpers.canvas';
 import Util from '../helpers/helpers.util';
 
@@ -783,7 +783,7 @@ const modules = {
       y1: this.chartRect.y1 + this.labelOffset.top,
       y2: this.chartRect.y2 - this.labelOffset.bottom,
     };
-    const mouseXIp = 5; // mouseInterpolation - increased for better edge detection
+    const mouseXIp = 1; // mouseInterpolation
     const mouseYIp = 10;
     const options = this.options;
 
@@ -858,7 +858,7 @@ const modules = {
    *
    * @returns {undefined}
    */
-  drawSyncedIndicator({ horizontal, label, mousePosition, useAxisTrigger }) {
+  drawSyncedIndicator({ horizontal, label, mousePosition }) {
     if (!mousePosition || !!horizontal !== !!this.options.horizontal) {
       return;
     }
@@ -882,7 +882,6 @@ const modules = {
     }
 
     this.overlayClear();
-
     const graphPos = {
       x1: this.chartRect.x1 + this.labelOffset.left,
       x2: this.chartRect.x2 - this.labelOffset.right,
@@ -890,17 +889,7 @@ const modules = {
       y2: this.chartRect.y2 - this.labelOffset.bottom,
     };
 
-    if (useAxisTrigger && label) {
-      const matchIndex = this.data.labels?.findIndex(l => l?.valueOf() === label?.valueOf());
-      if (matchIndex >= 0) {
-        const seriesId = Object.keys(this.seriesList)?.[0];
-        const dataPoint = this.seriesList?.[seriesId]?.data?.[matchIndex];
-        if (dataPoint?.xp !== undefined && dataPoint?.xp !== null) {
-          const yPosition = !isNil(dataPoint.yp) ? dataPoint.yp : (graphPos.y1 + graphPos.y2) / 2;
-          this.drawIndicator([dataPoint.xp, yPosition], this.options.indicator.color);
-        }
-      }
-    } else if (horizontal) {
+    if (horizontal) {
       const chartHeight = graphPos.y2 - graphPos.y1;
       const offsetY = (chartHeight * (label - fromTime)) / (toTime - fromTime) + graphPos.y1;
       this.drawIndicator([graphPos.x2, offsetY], this.options.indicator.color);

package/src/components/chart/scale/scale.js

@@ -93,8 +93,8 @@ class Scale {
     }
 
     if (this.startToZero) {
-        minValue = 0;
-      }
+      minValue = 0;
+    }
 
     if (maxValue === minValue) {
       maxValue += 1;
@@ -138,7 +138,6 @@ class Scale {
 
   /**
    * With range information, calculate how many labels in axis
-   * linear type은 scale.linear.js에서 처리
    * @param {object} range    min/max information
    *
    * @returns {object} steps, interval, min/max graph value
@@ -340,13 +339,6 @@ class Scale {
           ctx.beginPath();
           ticks[ix] = axisMinForLabel + (ix * stepValue);
 
-          const isZeroLine = ticks[ix] === 0;
-          if (isZeroLine && this.zeroLineColor) {
-            ctx.strokeStyle = this.zeroLineColor;
-          } else {
-            ctx.strokeStyle = this.gridLineColor;
-          }
-
           linePosition = labelCenter + aliasPixel;
           labelText = this.getLabelFormat(Math.min(axisMax, ticks[ix]), {
             prev: ticks[ix - 1] ?? '',
@@ -443,17 +435,15 @@ class Scale {
         }
 
         const mergedPlotBandOpt = defaultsDeep({}, plotBand, PLOT_BAND_OPTION);
-        const { from: userDefinedFrom, to: userDefinedTo, label: labelOpt } = mergedPlotBandOpt;
-        const from = userDefinedFrom ? Math.max(userDefinedFrom, axisMin) : axisMin;
-        const to = userDefinedTo ? Math.min(userDefinedTo, axisMax) : axisMax;
+        const { from, to, label: labelOpt } = mergedPlotBandOpt;
 
         this.setPlotBandStyle(mergedPlotBandOpt);
 
         let fromPos;
         let toPos;
         if (this.type === 'x') {
-          fromPos = Canvas.calculateX(from, axisMin, axisMax, xArea, minX);
-          toPos = Canvas.calculateX(to, axisMin, axisMax, xArea, minX);
+          fromPos = Canvas.calculateX(from ?? minX, axisMin, axisMax, xArea, minX);
+          toPos = Canvas.calculateX(to ?? maxX, axisMin, axisMax, xArea, minX);
 
           if (fromPos === null || toPos === null) {
             return;
@@ -461,8 +451,8 @@ class Scale {
 
           this.drawXPlotBand(fromPos, toPos, minX, maxX, minY, maxY);
         } else {
-          fromPos = Canvas.calculateY(from, axisMin, axisMax, yArea, maxY);
-          toPos = Canvas.calculateY(to, axisMin, axisMax, yArea, maxY);
+          fromPos = Canvas.calculateY(from ?? axisMin, axisMin, axisMax, yArea, maxY);
+          toPos = Canvas.calculateY(to ?? axisMax, axisMin, axisMax, yArea, maxY);
 
           if (fromPos === null || toPos === null) {
             return;

package/src/components/chart/scale/scale.linear.js

@@ -25,195 +25,15 @@ class LinearScale extends Scale {
    * Calculate interval
    * @param {object} range    range information
    *
-   * @returns {number}  interval (한 칸에 표시할 값의 간격)
+   * @returns {number} interval
    */
   getInterval(range) {
-    if (this.interval) return this.interval;
-
     const max = range.maxValue;
     const min = range.minValue;
-    const steps = range.maxSteps;
-
-    // step이 0이면 interval 계산 불가
-    if (!steps || steps <= 0) return 0;
-
-    // startToZero이고, 최소값이 음수일 경우 0을 반드시 포함
-    if (this.startToZero && min < 0) {
-      const totalRange = Math.abs(min) + Math.abs(max);
-
-      // 비율로 나눔
-      const negativeRatio = Math.abs(min) / totalRange;
-      const positiveRatio = Math.abs(max) / totalRange;
-
-      // 각 방향에 최소 1칸 이상 배정되도록 보장
-      let negativeSteps = Math.max(1, Math.round(negativeRatio * steps));
-      let positiveSteps = Math.max(1, steps - negativeSteps);
-
-      // 다시 합이 steps보다 커질 수도 있으니, 조정
-      if (negativeSteps + positiveSteps > steps) {
-        // 가장 큰 쪽에서 하나 줄임
-        if (negativeRatio > positiveRatio) {
-          negativeSteps -= 1;
-        } else {
-          positiveSteps -= 1;
-        }
-      }
-
-      return Math.ceil(
-        Math.max(
-          Math.abs(min) / (negativeSteps || 1),
-          Math.abs(max) / (positiveSteps || 1),
-        ),
-      );
-    }
-    return Math.ceil((max - min) / steps);
-  }
-
-    /**
-   * With range information, calculate how many labels in axis
-   * @param {object} range    min/max information
-   *
-   * @returns {object} steps, interval, min/max graph value
-   */
-  calculateSteps(range) {
-    const { maxValue, minValue } = range;
-    let { maxSteps = 1 } = range;
-
-    let interval = this.getInterval(range);
-    let graphMin = 0;
-    let graphMax = 0;
-
-    // 그래프 최대/최소 값 계산
-    if (minValue >= 0) {
-      // 전부 양수
-      graphMin = +minValue;
-      graphMax = Math.ceil(maxValue / interval) * interval;
-    } else if (maxValue >= 0) {
-      // 양수/음수 혼합
-      graphMin = Math.floor(minValue / interval) * interval;
-      graphMax = Math.ceil(maxValue / interval) * interval;
-    } else {
-      // 전부 음수
-      graphMax = +maxValue;
-      graphMin = Math.floor(minValue / interval) * interval;
-    }
-
-    const graphRange = graphMax - graphMin;
-    let numberOfSteps = Math.round(graphRange / interval);
-
-    // 특수 케이스: 양수 최소값, 최대값이 1일 경우
-    if (minValue > 0 && maxValue === 1) {
-      if (!this.decimalPoint) {
-        interval = 1;
-        numberOfSteps = 1;
-        maxSteps = 1;
-      } else if (maxSteps > 2) {
-        interval = 0.2;
-        numberOfSteps = 5;
-        maxSteps = 5;
-      } else {
-        interval = 0.5;
-        numberOfSteps = 2;
-        maxSteps = 2;
-      }
-    }
+    const step = range.maxSteps;
 
-    // 최대 스텝 수 조정
-    while (numberOfSteps > maxSteps) {
-      interval *= 2;
-      numberOfSteps = Math.round(graphRange / interval);
-      interval = Math.ceil(graphRange / numberOfSteps);
-    }
-
-    if (graphRange > (numberOfSteps * interval)) {
-      interval = Math.ceil(graphRange / numberOfSteps);
-    }
-
-    return {
-      steps: numberOfSteps,
-      interval,
-      graphMin,
-      graphMax,
-    };
+    return this.interval ? this.interval : Math.ceil((max - min) / step);
   }
-
-    /**
-   * Calculate min/max value, label and size information for axis
-   * @param {object} minMax    min/max information
-   * @param {object} scrollbarOpt scrollbar option
-   *
-   * @returns {object} min/max value and label
-   */
-    calculateScaleRange(minMax, scrollbarOpt) {
-      let maxValue;
-      let minValue;
-      let isDefaultMaxSameAsMin = false;
-
-      const range = scrollbarOpt?.use ? scrollbarOpt?.range : this.range;
-      if (Array.isArray(range) && range?.length === 2) {
-        if (this.options.type === 'heatMap') {
-          maxValue = range[1] > +minMax.max ? +minMax.max : range[1];
-          minValue = range[0] < +minMax.min ? +minMax.min : range[0];
-        } else {
-          maxValue = range[1];
-          minValue = range[0];
-        }
-      } else if (typeof range === 'function') {
-        [minValue, maxValue] = range(minMax.min, minMax.max);
-      } else {
-        maxValue = minMax.max;
-        minValue = minMax.min;
-      }
-
-      // autoScaleRatio 적용 케이스
-      if (this.autoScaleRatio) {
-        const temp = maxValue;
-        // 양수 방향에만 autoScaleRatio 적용
-        maxValue = Math.ceil(maxValue * (this.autoScaleRatio + 1));
-
-        if (maxValue > 0 && minValue < 0) {
-          // 양수/음수 혼합 케이스 -- 음수 방향에도 maxValue 증가분만큼 더하기
-          const diff = temp - maxValue;
-          minValue += diff;
-        } else if (maxValue < 0 && minValue < 0) {
-          // 전부 음수 케이스 -- 음수 방향에도 autoScaleRatio 적용
-          minValue = Math.ceil(minValue * (this.autoScaleRatio + 1));
-        }
-      }
-
-      // 0 기준 축 설정 케이스
-      if (this.startToZero) {
-        if (minValue > 0) {
-          minValue = 0;
-        }
-
-        if (maxValue < 0) {
-          maxValue = 0;
-        }
-      }
-
-      if (maxValue === minValue) {
-        maxValue += 1;
-        isDefaultMaxSameAsMin = true;
-      }
-
-      const minLabel = this.getLabelFormat(minValue);
-      const maxLabel = this.getLabelFormat(maxValue, {
-        isMaxValueSameAsMin: isDefaultMaxSameAsMin,
-      });
-
-      return {
-        min: minValue,
-        max: maxValue,
-        minLabel,
-        maxLabel,
-        size: Util.calcTextSize(
-          maxLabel,
-          Util.getLabelStyle(this.labelStyle),
-          this.labelStyle?.padding,
-        ),
-      };
-    }
 }
 
 export default LinearScale;

package/src/components/chart/uses.js

@@ -90,7 +90,6 @@ const DEFAULT_OPTIONS = {
   combo: false,
   tooltip: {
     use: true,
-    trigger: 'axis',
     sortByValue: true,
     backgroundColor: '#4C4C4C',
     fontColor: '#FFFFFF',