evui 3.4.206 → 3.4.208

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

@@ -1,268 +0,0 @@
-import Scale from './scale';
-import Util from '../helpers/helpers.util';
-
-class LinearScale extends Scale {
-  /**
-   * Transforming label by designated format
-   * @param {number} value                   label value
-   * @param {object} data                   data for formatting
-   *
-   * @returns {string} formatted label
-   */
-  getLabelFormat(value, data = {}) {
-    if (this.formatter) {
-      const formattedLabel = this.formatter(value, data);
-
-      if (typeof formattedLabel === 'string') {
-        return formattedLabel;
-      }
-    }
-
-    return Util.labelSignFormat(value, this.decimalPoint);
-  }
-
-  /**
-   * Calculate interval
-   * @param {object} range    range information
-   *
-   * @returns {number}  interval (한 칸에 표시할 값의 간격)
-   */
-  getInterval(range) {
-    if (this.interval) return this.interval;
-
-    let _interval = 0;
-
-    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;
-        }
-      }
-
-      _interval = Math.max(
-          Math.abs(min) / (negativeSteps || 1),
-          Math.abs(max) / (positiveSteps || 1),
-        );
-    } else {
-      _interval = (max - min) / steps;
-    }
-
-    return this.decimalPoint ? _interval : Math.ceil(_interval);
-  }
-
-      /**
-   * Get decimal point from range
-   * @param {object} {
-   *  graphRange: number,
-   *  numberOfSteps: number,
-   *  interval: number,
-   * }
-   * @returns {number} decimal point
-   */
-    getDecimalPointFromRange({
-      graphRange,
-      numberOfSteps,
-    }) {
-      if (numberOfSteps <= 0 || graphRange === 0) {
-        return 0;
-      }
-
-      const interval = graphRange / numberOfSteps;
-      if (interval === 0) {
-        return 0;
-      }
-
-      let decimals = 0;
-      let temp = interval;
-
-      while (temp < 1) {
-        temp *= 10;
-        decimals++;
-
-        if (decimals > 10) {
-          break;
-        }
-      }
-
-      return decimals;
-    }
-
-    /**
-   * 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;
-      }
-    }
-
-    // 최대 스텝 수 조정
-    while (numberOfSteps > maxSteps) {
-      interval *= 2;
-      numberOfSteps = Math.round(graphRange / interval);
-      interval = Math.ceil(graphRange / numberOfSteps);
-    }
-
-    if (graphRange > (numberOfSteps * interval)) {
-      interval = Math.ceil(graphRange / numberOfSteps);
-    }
-
-    if (this.decimalPoint === 'auto') {
-      this.decimalPoint = this?.getDecimalPointFromRange?.({
-        graphRange,
-        numberOfSteps,
-      });
-    }
-
-    return {
-      steps: numberOfSteps,
-      interval,
-      graphMin,
-      graphMax,
-    };
-  }
-
-    /**
-   * 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 적용
-        const _maxValue = maxValue * (this.autoScaleRatio + 1);
-        maxValue = this.decimalPoint ? _maxValue : Math.ceil(_maxValue);
-
-        if (maxValue > 0 && minValue < 0) {
-          // 양수/음수 혼합 케이스 -- 음수 방향에도 maxValue 증가분만큼 더하기
-          const diff = temp - maxValue;
-          minValue += diff;
-        } else if (maxValue < 0 && minValue < 0) {
-          // 전부 음수 케이스 -- 음수 방향에도 autoScaleRatio 적용
-          const _minValue = minValue * (this.autoScaleRatio + 1);
-          minValue = this.decimalPoint ? _minValue : Math.ceil(_minValue);
-        }
-      }
-
-      // 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/scale/scale.logarithmic.js

@@ -1,135 +0,0 @@
-import Scale from './scale';
-import Util from '../helpers/helpers.util';
-
-class LogarithmicScale extends Scale {
-  /**
-   * Calculate min/max value, label and size information for logarithmic scale
-   * @param {object} minMax    min/max information
-   *
-   * @returns {object} min/max value and label
-   */
-  calculateScaleRange(minMax) {
-    let maxValue;
-    let minValue;
-    let isDefaultMaxSameAsMin = false;
-    if (Array.isArray(this.range) && this.range.length === 2) {
-      maxValue = this.range[1];
-      minValue = this.range[0];
-    } else if (typeof range === 'function') {
-      [minValue, maxValue] = this.range(minMax.min, minMax.max);
-    } else {
-      maxValue = minMax.max;
-      minValue = minMax.min;
-    }
-
-    const rangeMagnitude = Util.calculateMagnitude(maxValue - minValue);
-    maxValue = Math.ceil(maxValue / (10 ** rangeMagnitude)) * (10 ** rangeMagnitude);
-
-    if (this.startToZero) {
-      minValue = 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)),
-    };
-  }
-
-  /**
-   * With range information, calculate how many labels in axis
-   * @param {object}  range          min/max information
-   * @param {boolean} skipFitting    determines if label skipping job.
-   *
-   * @returns {object} steps, interval, min/max graph value
-   */
-  calculateSteps(range, skipFitting) {
-    const maxValue = range.maxValue;
-    const minValue = range.minValue;
-    const maxSteps = range.maxSteps;
-    const rangeMagnitude = Util.calculateMagnitude(maxValue - minValue);
-
-    let interval = this.getInterval(range);
-    let numberOfSteps;
-
-    const graphMax = maxValue;
-    const graphMin = minValue;
-    const graphRange = graphMax - graphMin;
-
-    numberOfSteps = Math.round(graphRange / interval);
-
-    if (maxValue === 1) {
-      interval = 0.2;
-      numberOfSteps = 5;
-    }
-
-    while ((numberOfSteps > maxSteps || (numberOfSteps * 2) < maxSteps) && !skipFitting) {
-      if (numberOfSteps > maxSteps) {
-        interval *= 2;
-        numberOfSteps = Math.ceil(graphRange / interval);
-      } else if (rangeMagnitude >= 0) {
-        if ((interval / 2) % 1 === 0) {
-          interval /= 2;
-          numberOfSteps = Math.ceil(graphRange / interval);
-        } else {
-          break;
-        }
-      } else {
-        interval /= 2;
-        numberOfSteps = Math.ceil(graphRange / interval);
-      }
-    }
-
-    return {
-      steps: numberOfSteps,
-      interval,
-      graphMin,
-      graphMax: Math.ceil(graphMin + (numberOfSteps * interval)),
-    };
-  }
-
-  /**
-   * Transforming label by designated format
-   * @param {number} value                   label value
-   * @param {object} data                    data for formatting
-   *
-   * @returns {string} formatted label
-   */
-  getLabelFormat(value, data = {}) {
-    if (this.formatter) {
-      const formattedLabel = this.formatter(value, data);
-
-      if (typeof formattedLabel === 'string') {
-        return formattedLabel;
-      }
-    }
-
-    return Util.labelSignFormat(value, this.decimalPoint);
-  }
-
-  /**
-   * Calculate interval
-   * @param {object} range    range information
-   *
-   * @returns {number} interval
-   */
-  getInterval(range) {
-    const max = range.maxValue;
-    const min = range.minValue;
-    return 10 ** Util.calculateMagnitude(max - min);
-  }
-}
-
-export default LogarithmicScale;