250 lines
9.9 KiB
JavaScript
250 lines
9.9 KiB
JavaScript
|
|
/*
|
|
* Licensed to the Apache Software Foundation (ASF) under one
|
|
* or more contributor license agreements. See the NOTICE file
|
|
* distributed with this work for additional information
|
|
* regarding copyright ownership. The ASF licenses this file
|
|
* to you under the Apache License, Version 2.0 (the
|
|
* "License"); you may not use this file except in compliance
|
|
* with the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing,
|
|
* software distributed under the License is distributed on an
|
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
* KIND, either express or implied. See the License for the
|
|
* specific language governing permissions and limitations
|
|
* under the License.
|
|
*/
|
|
|
|
|
|
/**
|
|
* AUTO-GENERATED FILE. DO NOT MODIFY.
|
|
*/
|
|
|
|
/*
|
|
* Licensed to the Apache Software Foundation (ASF) under one
|
|
* or more contributor license agreements. See the NOTICE file
|
|
* distributed with this work for additional information
|
|
* regarding copyright ownership. The ASF licenses this file
|
|
* to you under the Apache License, Version 2.0 (the
|
|
* "License"); you may not use this file except in compliance
|
|
* with the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing,
|
|
* software distributed under the License is distributed on an
|
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
* KIND, either express or implied. See the License for the
|
|
* specific language governing permissions and limitations
|
|
* under the License.
|
|
*/
|
|
import { __extends } from "tslib";
|
|
import { round, mathRound, mathMin, getPrecision } from '../util/number.js';
|
|
import { addCommas } from '../util/format.js';
|
|
import Scale from './Scale.js';
|
|
import { getIntervalPrecision } from './helper.js';
|
|
import { getBreaksUnsafe, getScaleBreakHelper, hasBreaks, simplyParseBreakOption } from './break.js';
|
|
import { assert, clone } from 'zrender/lib/core/util.js';
|
|
import { getMinorTicks } from './minorTicks.js';
|
|
import { getScaleExtentForTickUnsafe, initBreakOrLinearMapper } from './scaleMapper.js';
|
|
import { warn } from '../util/log.js';
|
|
var IntervalScale = /** @class */function (_super) {
|
|
__extends(IntervalScale, _super);
|
|
function IntervalScale(setting) {
|
|
var _this = _super.call(this) || this;
|
|
_this.type = 'interval';
|
|
_this.parse = IntervalScale.parse;
|
|
setting = setting || {};
|
|
var breakParsed = simplyParseBreakOption(_this, setting);
|
|
var res = initBreakOrLinearMapper(_this, breakParsed, null);
|
|
// @ts-ignore
|
|
_this.brk = res.brk;
|
|
_this._cfg = {
|
|
interval: 0,
|
|
intervalPrecision: 2,
|
|
intervalCount: undefined,
|
|
niceExtent: undefined
|
|
};
|
|
return _this;
|
|
}
|
|
IntervalScale.parse = function (val) {
|
|
// `Scale#parse` (and its overrids) are typically applied at the axis values input
|
|
// in echarts option. e.g., `axis.min/max`, `dataZoom.min/max`, etc.
|
|
// but `series.data` is not included, which uses `dataValueHelper.ts`#`parseDataValue`.
|
|
// `Scale#parse` originally introduced in fb8c813215098b9d2458966229bb95c510883d5e
|
|
// at 2016 for dataZoom start/end settings (See `parseAxisModelMinMax`).
|
|
//
|
|
// Historically `scale/Interval.ts` returns the input value directly. But numeric
|
|
// values (such as a number-like string '123') effectively passed through here and
|
|
// were involved in calculations, which was error-prone and inconsistent with the
|
|
// declared TS return type. Previously such issues are fixed separately in different
|
|
// places case by case (such as #2475).
|
|
//
|
|
// Now, we perform actual parse to ensure its `number` type here. The parsing rule
|
|
// follows the series data parsing rule (`dataValueHelper.ts`#`parseDataValue`)
|
|
// and maintains compatibility as much as possible (thus a more strict parsing
|
|
// `number.ts`#`numericToNumber` is not used here.)
|
|
//
|
|
// FIXME: `ScaleDataValue` also need to be modified to include numeric string type,
|
|
// since it effectively does.
|
|
return val == null || val === '' ? NaN
|
|
// If string (like '-'), using '+' parse to NaN
|
|
// If object, also parse to NaN
|
|
: Number(val);
|
|
};
|
|
IntervalScale.prototype.getConfig = function () {
|
|
return clone(this._cfg);
|
|
};
|
|
IntervalScale.prototype.setConfig = function (cfg) {
|
|
var extent = getScaleExtentForTickUnsafe(this);
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
assert(cfg.interval != null);
|
|
if (cfg.intervalCount != null) {
|
|
assert(cfg.intervalCount >= -1 && cfg.intervalPrecision != null
|
|
// Do not support intervalCount on axis break currently.
|
|
&& !hasBreaks(this));
|
|
}
|
|
if (cfg.niceExtent != null) {
|
|
assert(isFinite(cfg.niceExtent[0]) && isFinite(cfg.niceExtent[1]));
|
|
assert(extent[0] <= cfg.niceExtent[0] && cfg.niceExtent[1] <= extent[1]);
|
|
assert(round(cfg.niceExtent[0] - cfg.niceExtent[1], getPrecision(cfg.interval)) <= cfg.interval);
|
|
}
|
|
}
|
|
// Reset all.
|
|
this._cfg = cfg = clone(cfg);
|
|
if (cfg.niceExtent == null) {
|
|
// Dropped the auto calculated niceExtent and use user-set extent.
|
|
// We assume users want to set both interval and extent to get a better result.
|
|
cfg.niceExtent = extent.slice();
|
|
}
|
|
if (cfg.intervalPrecision == null) {
|
|
cfg.intervalPrecision = getIntervalPrecision(cfg.interval);
|
|
}
|
|
};
|
|
/**
|
|
* In ascending order.
|
|
*/
|
|
IntervalScale.prototype.getTicks = function (opt) {
|
|
opt = opt || {};
|
|
var cfg = this._cfg;
|
|
var interval = cfg.interval;
|
|
var extent = getScaleExtentForTickUnsafe(this);
|
|
var niceExtent = cfg.niceExtent;
|
|
var intervalPrecision = cfg.intervalPrecision;
|
|
var scaleBreakHelper = getScaleBreakHelper();
|
|
var brk = this.brk;
|
|
var brkAvailable = scaleBreakHelper && brk;
|
|
var ticks = [];
|
|
// If interval is 0, return [];
|
|
if (!interval) {
|
|
return ticks;
|
|
}
|
|
if (opt.breakTicks === 'only_break' && brkAvailable) {
|
|
scaleBreakHelper.addBreaksToTicks(ticks, brk.breaks, extent);
|
|
return ticks;
|
|
}
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
assert(niceExtent != null);
|
|
}
|
|
// [CAVEAT]: If changing this logic, must sync it to `axisAlignTicks.ts`.
|
|
// A fail-safe is required since `interval` can be user specified, or for the case
|
|
// that using dataZoom toolbox and zoom repeatedly.
|
|
var safeLimit = 3000;
|
|
if (extent[0] < niceExtent[0]) {
|
|
ticks.push({
|
|
value: opt.expandToNicedExtent ? round(niceExtent[0] - interval, intervalPrecision) : extent[0]
|
|
});
|
|
}
|
|
var estimateNiceMultiple = function (tickVal, targetTick) {
|
|
return mathRound((targetTick - tickVal) / interval);
|
|
};
|
|
var intervalCount = cfg.intervalCount;
|
|
for (var tick = niceExtent[0], niceTickIdx = 0;; niceTickIdx++) {
|
|
// Consider case `_extent: [5.2, 5.8], _niceExtent: [6, 5], interval: 1`,
|
|
// `_intervalCount` makes sense iff `-1`.
|
|
// Consider case `_extent: [5, 5.8], _niceExtent: [5, 5], interval: 1`,
|
|
// `_intervalCount` makes sense iff `0`.
|
|
if (intervalCount == null) {
|
|
if (tick > niceExtent[1] || !isFinite(tick) || !isFinite(niceExtent[1])) {
|
|
break;
|
|
}
|
|
} else {
|
|
if (niceTickIdx > intervalCount) {
|
|
// nice ticks number should be `intervalCount + 1`
|
|
break;
|
|
}
|
|
// Consider cumulative error, especially caused by rounding, the last nice
|
|
// `tick` may be less than or greater than `niceExtent[1]` slightly.
|
|
tick = mathMin(tick, niceExtent[1]);
|
|
if (niceTickIdx === intervalCount) {
|
|
tick = niceExtent[1];
|
|
}
|
|
}
|
|
ticks.push({
|
|
value: tick
|
|
});
|
|
// Avoid rounding error
|
|
tick = round(tick + interval, intervalPrecision);
|
|
if (brk) {
|
|
var moreMultiple = brk.calcNiceTickMultiple(tick, estimateNiceMultiple);
|
|
if (moreMultiple >= 0) {
|
|
tick = round(tick + moreMultiple * interval, intervalPrecision);
|
|
}
|
|
}
|
|
if (ticks.length > 0 && tick === ticks[ticks.length - 1].value) {
|
|
// Consider out of safe float point, e.g.,
|
|
// -3711126.9907707 + 2e-10 === -3711126.9907707
|
|
break;
|
|
}
|
|
if (ticks.length > safeLimit) {
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
warn('Exceed safe limit in IntervalScale["getTicks"].');
|
|
}
|
|
return [];
|
|
}
|
|
}
|
|
// Consider this case: the last item of ticks is smaller
|
|
// than niceExtent[1] and niceExtent[1] === extent[1].
|
|
var lastNiceTick = ticks.length ? ticks[ticks.length - 1].value : niceExtent[1];
|
|
if (extent[1] > lastNiceTick) {
|
|
ticks.push({
|
|
value: opt.expandToNicedExtent ? round(lastNiceTick + interval, intervalPrecision) : extent[1]
|
|
});
|
|
}
|
|
if (brkAvailable) {
|
|
scaleBreakHelper.pruneTicksByBreak(opt.pruneByBreak, ticks, brk.breaks, function (item) {
|
|
return item.value;
|
|
}, cfg.interval, extent);
|
|
}
|
|
if (brkAvailable && opt.breakTicks !== 'none') {
|
|
scaleBreakHelper.addBreaksToTicks(ticks, brk.breaks, extent);
|
|
}
|
|
return ticks;
|
|
};
|
|
IntervalScale.prototype.getMinorTicks = function (splitNumber) {
|
|
return getMinorTicks(this, splitNumber, getBreaksUnsafe(this), this._cfg.interval);
|
|
};
|
|
IntervalScale.prototype.getLabel = function (tick, opt) {
|
|
if (tick == null) {
|
|
return '';
|
|
}
|
|
var precision = opt && opt.precision;
|
|
if (precision == null) {
|
|
precision = getPrecision(tick.value) || 0;
|
|
} else if (precision === 'auto') {
|
|
// Should be more precise then tick.
|
|
precision = this._cfg.intervalPrecision;
|
|
}
|
|
// (1) If `precision` is set, 12.005 should be display as '12.00500'.
|
|
// (2) Use `round` (toFixed) to avoid scientific notation like '3.5e-7'.
|
|
var dataNum = round(tick.value, precision, true);
|
|
return addCommas(dataNum);
|
|
};
|
|
IntervalScale.type = 'interval';
|
|
return IntervalScale;
|
|
}(Scale);
|
|
Scale.registerClass(IntervalScale);
|
|
export default IntervalScale; |