fix: (1) Fix time axis reach safeLimit when value scale is milisecond. (2) Fix regression - containShape should be word properly in single value case. And simply the code.

Author: 100pah

src/chart/helper/axisSnippets.ts

@@ -43,12 +43,16 @@ export function createBandWidthBasedAxisContainShapeHandler(axisStatKey: AxisSta
     //                         |----|----------------------|--|
     //                  minValNew    minValOld     maxValOld maxValNew
     //     (Note: `|---|` above represents "pixels" rather than "data".)
+    //  Regarding single data item case:
+    //    (See test/axis-extreme2.html)
+    //    - TimeScale and OrdinalScale do not need to handle it, since they have
+    //      ensured single data item is laid out at the middle of the axis.
+    //    - IntervalScale and LogScale ...................
 
-    return function (axis, scale, ecModel) {
+    return function (axis, ecModel) {
         const bandWidthResult = calcBandWidth(axis, {fromStat: {key: axisStatKey}});
-        const invRatio = bandWidthResult.invRatio;
-        if (isNullableNumberFinite(invRatio) && isNullableNumberFinite(bandWidthResult.w)) {
-            return [-bandWidthResult.w / 2 * invRatio, bandWidthResult.w / 2 * invRatio];
+        if (isNullableNumberFinite(bandWidthResult.w2)) {
+            return [-bandWidthResult.w2 / 2, bandWidthResult.w2 / 2];
         }
     };
 }

src/component/dataZoom/AxisProxy.ts

@@ -48,10 +48,7 @@ interface MinMaxSpan {
 
 export interface AxisProxyWindow {
     // NOTE: May include non-effective portion.
-    value: number[];
-    // Although `dataZoom` effectively calculates based on "noZoomMapMM" (where
-    // containShape is considered), `dataZoom` labels always show `noZoomEffMM`.
-    noZoomEffMM: ScaleRawExtentResultForZoom['noZoomEffMM'];
+    value: ScaleRawExtentResultForZoom;
     percent: number[];
     // Percent invert from "value window", which may be slightly different from "percent window" due to some
     // handling such as rounding. The difference may be magnified in cases like "alignTicks", so we use
@@ -151,8 +148,6 @@ class AxisProxy {
 
     /**
      * [CAVEAT] Keep this method pure, so that it can be called multiple times.
-     *
-     * Only calculate by given range and cumulative series data extent, do not change anything.
      */
     calculateDataWindow(
         opt: {
@@ -162,7 +157,7 @@ class AxisProxy {
             endValue?: number | string | Date
         }
     ): AxisProxyWindow {
-        const {noZoomMapMM: dataExtent, noZoomEffMM} = this._extent;
+        const dataExtent = this._extent;
         const axis = this.getAxisModel().axis;
         const scale = axis.scale;
         const dataZoomModel = this._dataZoomModel;
@@ -330,7 +325,6 @@ class AxisProxy {
 
         return {
             value: valueWindow,
-            noZoomEffMM: noZoomEffMM.slice(),
             percent: percentWindow,
             percentInverted: percentInvertedWindow,
             valuePrecision: precision,
@@ -376,10 +370,6 @@ class AxisProxy {
         }
         const {percent, value} = this._window = this.calculateDataWindow(opt);
 
-        // For value axis, if min/max/scale are not set, we just use the extent obtained
-        // by series data, which may be a little different from the extent calculated by
-        // `axisHelper.getScaleExtent`. But the different just affects the experience a
-        // little when zooming. So it will not be fixed until some users require it strongly.
         if (percent[0] !== 0) {
             rawExtentInfo.setZoomMM(0, value[0]);
         }
@@ -487,7 +477,7 @@ class AxisProxy {
     private _updateMinMaxSpan() {
         const minMaxSpan = this._minMaxSpan = {} as MinMaxSpan;
         const dataZoomModel = this._dataZoomModel;
-        const dataExtent = this._extent.noZoomMapMM;
+        const dataExtent = this._extent;
 
         each(['min', 'max'], function (minMax) {
             let percentSpan = dataZoomModel.get(minMax + 'Span' as 'minSpan' | 'maxSpan');

src/component/dataZoom/SliderZoomView.ts

@@ -22,7 +22,7 @@ import * as eventTool from 'zrender/src/core/event';
 import * as graphic from '../../util/graphic';
 import * as throttle from '../../util/throttle';
 import DataZoomView from './DataZoomView';
-import { linearMap, asc, parsePercent, round, mathMax, mathMin } from '../../util/number';
+import { linearMap, asc, parsePercent, round } from '../../util/number';
 import * as layout from '../../util/layout';
 import sliderMove from '../helper/sliderMove';
 import GlobalModel from '../../model/Global';
@@ -1143,10 +1143,7 @@ function formatLabel(
     // Do not display values out of `SCALE_EXTENT_KIND_EFFECTIVE` - generally they are meaningless.
     // For example, `scaleExtent[0]` is often `0`, and negative values are unlikely to be meaningful.
     // That is, "nice" expansion and `SCALE_EXTENT_KIND_MAPPING` expansion are always not display in labels.
-    const value = (extentIdx ? mathMin : mathMax)(
-        window.value[extentIdx],
-        window.noZoomEffMM[extentIdx],
-    );
+    const value = window.value[extentIdx];
 
     const valueStr = (value == null || isNaN(value))
         ? ''

src/coord/axisAlignTicks.ts

@@ -192,7 +192,7 @@ export function scaleCalcAlign(
 
     function loopIncreaseInterval(cb: () => boolean) {
         // Typically this loop runs less than 5 times. But we still
-        // use a safeguard for future changes.
+        // use a fail-safe for future changes.
         const LOOP_MAX = 50;
         let loopGuard = 0;
         for (; loopGuard < LOOP_MAX; loopGuard++) {
@@ -304,7 +304,7 @@ export function scaleCalcAlign(
                     //  - In LogScale, series data are usually either all > 1 or all < 1, rather than both,
                     //    that is, logarithm result is typically either all positive or all negative.
                     let moreCountPair: number[];
-                    const mayEnhanceZero = targetExtentInfo.needCrossZero || isTargetLogScale;
+                    const mayEnhanceZero = targetExtentInfo.incl0 || isTargetLogScale;
                     // `bounds < 0` or `bounds > 0` may require more complex handling, so we only auto handle
                     // `bounds === 0`.
                     if (mayEnhanceZero && targetExtent[0] === 0) {

src/coord/axisBand.ts

@@ -17,10 +17,9 @@
 * under the License.
 */
 
-import { assert, each } from 'zrender/src/core/util';
+import { assert, each, retrieve2 } from 'zrender/src/core/util';
 import { NullUndefined } from '../util/types';
 import type Axis from './Axis';
-import type Scale from '../scale/Scale';
 import { isOrdinalScale } from '../scale/helper';
 import { isNullableNumberFinite, mathAbs, mathMax } from '../util/number';
 import {
@@ -34,15 +33,15 @@ import type SeriesModel from '../model/Series';
 const FALLBACK_BAND_WIDTH_RATIO = 0.8;
 
 export type AxisBandWidthResult = {
-    // The result `bandWidth`. In pixel.
+    // bandWidth in pixel.
     // Never be null/undefined.
-    // May be NaN if no meaningfull `bandWidth`. But it's unlikely to be NaN, since edge cases
+    // May be NaN if no meaningfull value. But it's unlikely to be NaN, since edge cases
     // are handled internally whenever possible.
     w: number;
-    // This is a ratio from pixel span to data span.
-    // Note that the conversion can not be performed if it is not valid, typically when only
-    // one or no series data item exists on the axis.
-    invRatio?: number | NullUndefined;
+    // bandWidth in data space.
+    // Never be null/undefined.
+    // May be NaN if no meaningfull value, typically when no valid series data item.
+    w2: number;
 };
 
 /**
@@ -86,16 +85,36 @@ export function calcBandWidth(
     opt?: CalculateBandWidthOpt | NullUndefined
 ): AxisBandWidthResult {
     opt = opt || {};
-    const out: AxisBandWidthResult = {w: NaN};
+    const out: AxisBandWidthResult = {w: NaN, w2: NaN};
     const scale = axis.scale;
     const fromStat = opt.fromStat;
     const min = opt.min;
 
+    // [BAND_WIDTH_USED_SCALE_LINEAR_SPAN]
+    //  - Band width should always respect to the currently specified extent, and `SCALE_EXTENT_KIND_MAPPING`
+    //    should be used if specified.
+    //    Otherwise, the result may incorrect, especially when data count is small.
+    //    For example, when "containShape" is calculating, no `SCALE_EXTENT_KIND_MAPPING` is set, so here only
+    //    `SCALE_EXTENT_KIND_EFFECTIVE` is returned, say, `[3, 5]`, based on which a `SCALE_EXTENT_KIND_MAPPING`
+    //    is calculated, say `[2.5, 5.5]` (expanded by `0.5`). Then when rendering, that `SCALE_EXTENT_KIND_MAPPING`
+    //    is returned here.
+    //    See AXIS_CONTAIN_SHAPE_COMMON_STRATEGY for more details.
+    //  - The span should be in the linear space (typically, the innermost space).
+    //  - We use the scale extent after being zoommed and `intervalScaleEnsureValidExtent`-ish applied and
+    //    "nice"/"align" applied, because:
+    //    - For OrdinalScale, fine;
+    //    - For numeric scale, `scaleLinearSpan` is normally not used for a consistent result when `dataZoom`
+    //      is applied, but used when none or single data item case.
+    const scaleLinearSpan = getScaleLinearSpanForMapping(scale);
+    const axisExtent = axis.getExtent();
+    // Always use a new pxSpan because it may be changed in `grid` contain label calculation.
+    const pxSpan = mathAbs(axisExtent[1] - axisExtent[0]);
+
     if (isOrdinalScale(scale)) {
-        calcBandWidthForCategoryAxis(out, axis, scale);
+        calcBandWidthForCategoryAxis(out, axis, scaleLinearSpan, pxSpan);
     }
     else if (fromStat) {
-        calcBandWidthForNumericAxis(out, axis, scale, fromStat);
+        calcBandWidthForNumericAxis(out, axis, scaleLinearSpan, pxSpan, fromStat);
     }
     else if (min == null) {
         if (__DEV__) {
@@ -111,52 +130,36 @@ export function calcBandWidth(
     return out;
 }
 
-/**
- * Only reasonable on 'category'.
- *
- * It can be used as a fallback, as it does not produce a significant negative impact
- * on non-category axes.
- *
- * @see CalculateBandWidthOpt
- */
 function calcBandWidthForCategoryAxis(
     out: AxisBandWidthResult,
     axis: Axis,
-    scale: Scale
+    scaleLinearSpan: number,
+    pxSpan: number,
 ): void {
-    const axisExtent = axis.getExtent();
-    const pxSpan = mathAbs(axisExtent[1] - axisExtent[0]);
-    // See the reason on BAND_WIDTH_USED_LINEAR_SCALE_SPAN.
-    const linearScaleSpan = getScaleLinearSpanForMapping(scale);
     const onBand = axis.onBand;
 
-    let len = linearScaleSpan + (onBand ? 1 : 0);
+    let len = scaleLinearSpan + (onBand ? 1 : 0);
     // Fix #2728, avoid NaN when only one data.
     len === 0 && (len = 1);
 
     out.w = pxSpan / len;
     // NOTE:
-    //  - When `linearScaleSpan === 0`, no need to expand extent.
+    //  - When `scaleLinearSpan === 0`, no need to expand extent.
     //  - `onBand: true` (`boundaryGap: true`) does not need to support `containShape`,
     //    thereby no `invRatio`.
-    if (!onBand && linearScaleSpan && pxSpan) {
-        out.invRatio = linearScaleSpan / pxSpan;
+    if (!onBand && scaleLinearSpan && pxSpan) {
+        out.w2 = out.w * scaleLinearSpan / pxSpan;
     }
 }
 
-/**
- * @see CalculateBandWidthOpt
- */
 function calcBandWidthForNumericAxis(
     out: AxisBandWidthResult,
     axis: Axis,
-    scale: Scale,
+    scaleLinearSpan: number,
+    pxSpan: number,
     fromStat: CalculateBandWidthOpt['fromStat'],
 ): void {
 
-    let bandWidth = NaN;
-    let invRatio: number | NullUndefined;
-
     if (__DEV__) {
         assert(fromStat);
     }
@@ -184,36 +187,16 @@ function calcBandWidthForNumericAxis(
         }
     );
 
-    const axisExtent = axis.getExtent();
-    // Always use a new pxSpan because it may be changed in `grid` contain label calculation.
-    const pxSpan = mathAbs(axisExtent[1] - axisExtent[0]);
-
-    // [BAND_WIDTH_USED_LINEAR_SCALE_SPAN]
-    // Here we deliberately use `getScaleLinearSpanForMapping` rather than `scale.getExtent()`,
-    // because band width should always respect to the currently specified extent (e.g., specified by
-    // `calcContainShape`). Otherwise, the result may incorrect, especially when data count is small.
-    // For example, when "containShape" is calculating, no `SCALE_EXTENT_KIND_MAPPING` is set, so here only
-    // `SCALE_EXTENT_KIND_EFFECTIVE` is returned, say, `[3, 5]`, based on which a `SCALE_EXTENT_KIND_MAPPING`
-    // is calculated, say `[2.5, 5.5]` (expanded by `0.5`). Then when rendering, that `SCALE_EXTENT_KIND_MAPPING`
-    // is returned here.
-    // See AXIS_CONTAIN_SHAPE_COMMON_STRATEGY for more details.
-    const linearScaleSpan = getScaleLinearSpanForMapping(scale);
-
-    // `linearScaleSpan` may be `0` or `Infinity` or `NaN`, since normalizers like
+    // `scaleLinearSpan` may be `0` or `Infinity` or `NaN`, since normalizers like
     // `intervalScaleEnsureValidExtent` may not have been called yet.
-    if (isNullableNumberFinite(linearScaleSpan) && linearScaleSpan > 0
+    if (isNullableNumberFinite(scaleLinearSpan) && scaleLinearSpan > 0
         && isNullableNumberFinite(bandWidthInData)
     ) {
-        // NOTE: even when the `bandWidth` is far smaller than `1`, we should still preserve the
-        // precision, because it is required to convert back to data space by `invRatio` for
-        // displaying of zoomed ticks and band.
-        bandWidth = pxSpan / linearScaleSpan * bandWidthInData;
-        invRatio = linearScaleSpan / pxSpan;
+        out.w = pxSpan / scaleLinearSpan * bandWidthInData;
+        out.w2 = bandWidthInData;
     }
     else if (allSingularOrNone) {
-        bandWidth = pxSpan * FALLBACK_BAND_WIDTH_RATIO;
+        out.w = pxSpan * FALLBACK_BAND_WIDTH_RATIO;
+        out.w2 = out.w * scaleLinearSpan / pxSpan;
     }
-
-    out.w = bandWidth;
-    out.invRatio = invRatio;
 }

src/coord/axisModelCommonMixin.ts

@@ -30,7 +30,7 @@ interface AxisModelCommonMixin<Opt extends AxisBaseOption> extends Pick<Model<Op
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 class AxisModelCommonMixin<Opt extends AxisBaseOption> {
 
-    getNeedCrossZero(): boolean {
+    needIncludeZero(): boolean {
         return !(this.option as ValueAxisBaseOption).scale;
     }
 

src/coord/axisNiceTicks.ts

@@ -266,7 +266,7 @@ export function scaleCalcNice2(
     });
 
     if (axis && ecModel) {
-        adoptScaleExtentKindMapping(axis, scale, rawExtentResult);
+        adoptScaleExtentKindMapping(axis, scale, rawExtentResult, ecModel);
     }
 
     if (__DEV__) {

src/coord/cartesian/Grid.ts

@@ -59,7 +59,7 @@ import {
     createCartesianAxisViewCommonPartBuilder,
     updateCartesianAxisViewCommonPartBuilder,
 } from './cartesianAxisHelper';
-import { AxisBaseOptionCommon, CategoryAxisBaseOption, NumericAxisBaseOptionCommon } from '../axisCommonTypes';
+import { AxisBaseOptionCommon, NumericAxisBaseOptionCommon } from '../axisCommonTypes';
 import { AxisBaseModel } from '../AxisBaseModel';
 import { isIntervalOrLogScale, isOrdinalScale } from '../../scale/helper';
 import { scaleCalcAlign } from '../axisAlignTicks';