fix regression: onZero should be backward compatibility. And clarify comments.

Author: 100pah

src/chart/helper/axisSnippets.ts

@@ -43,11 +43,6 @@ 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, ecModel) {
         const bandWidthResult = calcBandWidth(axis, {fromStat: {key: axisStatKey}});

src/component/dataZoom/AxisProxy.ts

@@ -36,7 +36,6 @@ import {
     AXIS_EXTENT_INFO_BUILD_FROM_DATA_ZOOM, scaleRawExtentInfoCreate,
     ScaleRawExtentResultForZoom,
 } from '../../coord/scaleRawExtentInfo';
-import { discourageOnAxisZero } from '../../coord/axisHelper';
 
 
 interface MinMaxSpan {
@@ -353,8 +352,6 @@ class AxisProxy {
         const axis = this.getAxisModel().axis;
         scaleRawExtentInfoCreate(this.ecModel, axis, AXIS_EXTENT_INFO_BUILD_FROM_DATA_ZOOM);
 
-        discourageOnAxisZero(axis, {dz: true});
-
         const rawExtentInfo = axis.scale.rawExtentInfo;
         this._extent = rawExtentInfo.makeNoZoom();
 

src/coord/axisBand.ts

@@ -45,19 +45,17 @@ export type AxisBandWidthResult = {
     w2: number;
 };
 
-/**
- * PENDING: Should the `bandWidth` strategy be chosen by users, or auto-determined basesd on
- * performance?
- */
 type CalculateBandWidthOpt = {
     // Only used on non-'category' axes. Calculate `bandWidth` based on statistics.
     // Require `requireAxisStatistics` to be called.
     fromStat?: {
-        // Either `axisStatKey` or `series` is required.
-        // If multiple axis statistics can be queried by `series`, currently we only support to return a
-        // maximum `bandWidth`, which is suitable for cases like "axis pointer shadow".
-        sers?: (SeriesModel | NullUndefined)[] | NullUndefined;
+        // Either `key` or `sers` is required.
+        //  - `key`: Calculate `bandWidth` based on a series collection defined by the `AxisStatKey`.
         key?: AxisStatKey;
+        //  - `sers`: Query all keys by the given series collection and union the corresponding bandWidth.
+        //    PENDING: If multiple axis statistics can be queried by `series`, currently we only support
+        //    to return a maximum `bandWidth`, which is suitable for cases like "axis pointer shadow".
+        sers?: (SeriesModel | NullUndefined)[] | NullUndefined;
     };
     // It also act as a fallback for NaN/null/undefined result.
     min?: number;

src/coord/axisHelper.ts

@@ -59,14 +59,9 @@ import ComponentModel from '../model/Component';
 
 
 const axisInner = makeInner<{
-    noOnMyZero: DiscourageOnAxisZeroCondition;
+    noOnMyZero: boolean;
 }, Axis>();
 
-type DiscourageOnAxisZeroCondition = {
-    dz?: boolean;
-    base?: boolean;
-};
-
 
 export function determineAxisType(
     model: Model<Pick<AxisBaseOption, 'type'>>
@@ -162,20 +157,15 @@ export const SCALE_VALUE_POSITION_KIND_EDGE = 2;
 export const SCALE_VALUE_POSITION_KIND_OUTSIDE = 3;
 
 
-export function discourageOnAxisZero(axis: Axis, reason: Partial<DiscourageOnAxisZeroCondition>): void {
-    zrUtil.defaults(axisInner(axis).noOnMyZero || (axisInner(axis).noOnMyZero = {}), reason);
+export function discourageOnAxisZero(axis: Axis): void {
+    axisInner(axis).noOnMyZero = true;
 }
 
 /**
  * `true`: Prevent orthoganal axes from positioning at the zero point of this axis.
  */
 export function isOnAxisZeroDiscouraged(axis: Axis): boolean {
-    const noOnMyZero = axisInner(axis).noOnMyZero;
-    // Empirically, onZero causes weird effect when dataZoom is used on an "base axis". Consider
-    // bar series as an example. And also consider when `SCALE_EXTENT_KIND_MAPPING` is used, where
-    // the axis line is likely to cross the series shapes unexpectedly.
-    // Conservatively, we use "&&" rather than "||" here.
-    return noOnMyZero && noOnMyZero.dz && noOnMyZero.base;
+    return axisInner(axis).noOnMyZero;
 }
 
 /**

src/coord/axisStatistics.ts

@@ -126,10 +126,12 @@ export type AxisStatKeyedClient = {
 
 /**
  * Within each individual axis, different groups of relevant series and statistics are
- * designated by `AxisStatKey`. In most case `seriesType` is used as `AxisStatKey`.
+ * designated by a `AxisStatKey`.
+ * In most case `seriesType` is used as `AxisStatKey`.
  */
 export type AxisStatKey = string & {_: 'AxisStatKey'}; // Nominal to avoid misusing.
-type ClientQueryKey = string & {_: 'ClientQueryKey'}; // Nominal to avoid misusing; internal usage.
+
+type ClientLookupKey = string & {_: 'ClientLookupKey'}; // Nominal to avoid misusing; internal usage.
 
 export type AxisStatMetrics = {
 
@@ -468,7 +470,7 @@ function performStatisticsForRecord(
 // For performance optimization.
 const tmpValueBuffer = tryEnsureTypedArray(
     {ctor: Float64ArrayCtor},
-    50 // arbitrary. May be expanded if needed.
+    50 // An arbitrary initial capability.
 );
 
 /**
@@ -525,8 +527,8 @@ export function associateSeriesWithAxis(
     const seriesType = seriesModel.subType;
     const isBaseAxis = seriesModel.getBaseAxis() === axis;
 
-    const client = clientsByQueryKey.get(makeClientQueryKey(seriesType, isBaseAxis, coordSysType))
-        || clientsByQueryKey.get(makeClientQueryKey(seriesType, isBaseAxis, null));
+    const client = clientsForLookup.get(makeClientLookupKey(seriesType, isBaseAxis, coordSysType))
+        || clientsForLookup.get(makeClientLookupKey(seriesType, isBaseAxis, null));
     if (!client) {
         return;
     }
@@ -554,16 +556,16 @@ export function associateSeriesWithAxis(
  * NOTE: Currently, the scenario is simple enough to look up clients by hash map.
  * Otherwise, a caller-provided `filter` may be an alternative if more complex requirements arise.
  */
-function makeClientQueryKey(
+function makeClientLookupKey(
     seriesType: ComponentSubType,
     isBaseAxis: boolean | NullUndefined,
     coordSysType: CoordinateSystem['type'] | NullUndefined
-): ClientQueryKey {
+): ClientLookupKey {
     return (
         seriesType
         + AXIS_STAT_KEY_DELIMITER + retrieve2(isBaseAxis, true)
         + AXIS_STAT_KEY_DELIMITER + (coordSysType || '')
-    ) as ClientQueryKey;
+    ) as ClientLookupKey;
 }
 
 /**
@@ -575,18 +577,18 @@ export function requireAxisStatistics(
     registers: EChartsExtensionInstallRegisters,
     client: AxisStatKeyedClient
 ): void {
-    const queryKey = makeClientQueryKey(client.seriesType, client.baseAxis, client.coordSysType);
+    const clientKey = makeClientLookupKey(client.seriesType, client.baseAxis, client.coordSysType);
 
     if (__DEV__) {
         assert(client.seriesType
             && client.key
-            && !clientsCheckStatKey.get(client.key)
-            && !clientsByQueryKey.get(queryKey)
+            && !clientsForCheckingStatKey.get(client.key)
+            && !clientsForLookup.get(clientKey)
         ); // More checking is performed in `axSerPairCheck`.
-        clientsCheckStatKey.set(client.key, 1);
+        clientsForCheckingStatKey.set(client.key, 1);
     }
 
-    clientsByQueryKey.set(queryKey, client);
+    clientsForLookup.set(clientKey, client);
 
     callOnlyOnce(registers, function () {
         registers.registerProcessor(registers.PRIORITY.PROCESSOR.AXIS_STATISTICS, {
@@ -597,8 +599,8 @@ export function requireAxisStatistics(
     });
 }
 
-let clientsCheckStatKey: HashMap<1, AxisStatKey>;
+let clientsForCheckingStatKey: HashMap<1, AxisStatKey>;
 if (__DEV__) {
-    clientsCheckStatKey = createHashMap();
+    clientsForCheckingStatKey = createHashMap();
 }
-const clientsByQueryKey: HashMap<AxisStatKeyedClient, ClientQueryKey> = createHashMap();
+const clientsForLookup: HashMap<AxisStatKeyedClient, ClientLookupKey> = createHashMap();

src/coord/cartesian/Grid.ts

@@ -32,7 +32,6 @@ import {
     shouldAxisShow,
     retrieveAxisBreaksOption,
     determineAxisType,
-    discourageOnAxisZero,
     isOnAxisZeroDiscouraged,
     SCALE_VALUE_POSITION_KIND_OUTSIDE,
     SCALE_VALUE_POSITION_KIND_EDGE,
@@ -454,8 +453,6 @@ class Grid implements CoordinateSystemMaster {
 
                 cartesian.addAxis(xAxis);
                 cartesian.addAxis(yAxis);
-
-                discourageOnAxisZero(cartesian.getBaseAxis(), {base: true});
             });
         });
 
@@ -699,6 +696,13 @@ function canOnZeroToAxis(
         && kindEffective !== SCALE_VALUE_POSITION_KIND_OUTSIDE;
 
     if (can && onZeroOption === 'auto'
+        // Historically, "value" axis and "log" axis has been using `onZero: true` as the default.
+        // It suitable for mathematic cases, even when dataZoom exists (e.g., `clip.html`), or cases
+        // need to distinguish positive and negative data. However, it probably causes odd effect if
+        // a "value axis" is laid on zero of a "base axis" in bar/candlestick, where the axis line
+        // would likely cross shapes when `SCALE_EXTENT_KIND_MAPPING` is applied.
+        // Therefore, we preserve backward compatibility of the default `onZero: true`, but exclude
+        // cases that `containShape` is applied.
         && (
             isOnAxisZeroDiscouraged(axis)
             || (

src/coord/scaleRawExtentInfo.ts

@@ -37,7 +37,7 @@ import {
     unionExtentEndFromNumber,
     ensureExtentAscSimply,
 } from '../util/model';
-import { getDataDimensionsOnAxis, isAxisOnBand } from './axisHelper';
+import { discourageOnAxisZero, getDataDimensionsOnAxis, isAxisOnBand } from './axisHelper';
 import {
     getCoordForCoordSysUsageKindBox
 } from '../core/CoordinateSystem';
@@ -786,6 +786,8 @@ export function adoptScaleExtentKindMapping(
                 linearSupplement = linearSupplement || [0, 0];
                 unionExtentStartFromNumber(linearSupplement, singleLinearSupplement[0]);
                 unionExtentEndFromNumber(linearSupplement, singleLinearSupplement[1]);
+
+                discourageOnAxisZero(axis);
             }
         }
     });

src/core/Scheduler.ts

@@ -108,7 +108,7 @@ interface OverallTaskContext extends TaskContext {
 }
 interface StubTaskContext extends TaskContext {
     model: SeriesModel;
-    dirtyOnOverallProgress: boolean;
+    dirtyOnOverallProgress: StageHandler['dirtyOnOverallProgress'];
 };
 
 class Scheduler {

src/util/types.ts

@@ -379,6 +379,8 @@ export interface StageHandler {
      *
      * The `overallReset` method is called iff this task is "dirty" (See `Task['dirty']`).
      * See EC_TASK_DIRTY for a summary of possible `dirty()` calls.
+     *
+     * @see dirtyOnOverallProgress If a OVERALL_STAGE_TASK need to handle series data.
      */
     overallReset?: StageHandlerOverallReset;
 
@@ -402,10 +404,12 @@ export interface StageHandler {
     /**
      * This is a temporary mechanism primarily for a dataZoom case in `appendData`.
      *
-     * Ordinarily, `overallReset` is not called in progress in the subsequent frames,
-     * but `dirtyOnOverallProgress: true` allows all pipelines to be blocked until
-     * this stage, thereby no `overallReset` call being omitted.
-     * (See PerformStageTaskOpt['block'] for its meaning.)
+     * Ordinarily, `overallReset` is NOT called in progress in the subsequent frames, which is suitable
+     * for most OVERALL_STAGE_TASK, where no series data related operations is performed (e.g., color
+     * palette task).
+     * But some certain OVERALL_STAGE_TASK need to handle series data, where `dirtyOnOverallProgress: true`
+     * is required. It allows all pipelines to be blocked until this stage, thereby no `overallReset` call
+     * being omitted. (See PerformStageTaskOpt['block'] for its meaning.) (e.g., dataZoom task)
      *
      * NOTE_IMPL: It will set this OVERALL_STAGE_TASK dirty when the pipeline progress.
      * Moreover, to avoid calling the OVERALL_STAGE_TASK each frame (too frequent),