This is an automated email from the ASF dual-hosted git repository. sushuang pushed a commit to branch typescript in repository https://gitbox.apache.org/repos/asf/incubator-echarts.git
commit d69ffcd42058385724ecea0af65a5773df5cf89d Author: 100pah <[email protected]> AuthorDate: Thu Feb 20 02:13:08 2020 +0800 'scale' to ts --- src/coord/axisHelper.ts | 19 +-- src/data/List.ts | 6 +- src/data/OrdinalMeta.ts | 16 +-- src/scale/Interval.ts | 137 +++++++++------------- src/scale/Log.ts | 149 +++++++++++------------ src/scale/Ordinal.ts | 108 ++++++++--------- src/scale/Scale.ts | 273 ++++++++++++++++++++++--------------------- src/scale/Time.ts | 84 +++++++------ src/scale/helper.ts | 47 ++++---- src/util/format.ts | 2 +- src/util/number.ts | 7 +- src/util/types.ts | 10 +- test/build/test-transform.js | 5 +- 13 files changed, 416 insertions(+), 447 deletions(-) diff --git a/src/coord/axisHelper.ts b/src/coord/axisHelper.ts index 071bdde..9e51dd6 100644 --- a/src/coord/axisHelper.ts +++ b/src/coord/axisHelper.ts @@ -34,6 +34,7 @@ import BoundingRect from 'zrender/src/core/BoundingRect'; import '../scale/Time'; import '../scale/Log'; +import TimeScale from '../scale/Time'; /** * Get axis scale extent before niced. @@ -252,17 +253,19 @@ export function createScaleByModel(model, axisType) { switch (axisType) { // Buildin scale case 'category': - return new OrdinalScale( - model.getOrdinalMeta + return new OrdinalScale({ + ordinalMeta: model.getOrdinalMeta ? model.getOrdinalMeta() : model.getCategories(), - [Infinity, -Infinity] - ); - case 'value': - return new IntervalScale(); - // Extended scale, like time and log + extent: [Infinity, -Infinity] + }); + case 'time': + return new TimeScale({ + useUTC: model.ecModel.get('useUTC') + }) default: - return (Scale.getClass(axisType) || IntervalScale).create(model); + // case 'value'/'interval', 'log', or others. + return new (Scale.getClass(axisType) || IntervalScale)(); } } } diff --git a/src/data/List.ts b/src/data/List.ts index 0f2f93c..3fbc763 100644 --- a/src/data/List.ts +++ b/src/data/List.ts @@ -36,7 +36,7 @@ import {ArrayLike, Dictionary, FunctionPropertyNames} from 'zrender/src/core/typ import Element from 'zrender/src/Element'; import { DimensionIndex, DimensionName, ECElement, DimensionLoose, OptionDataItem, - ParsedDataValue, ParsedDataNumeric, OrdinalRawValueIndex, DimensionUserOuput, ModelOption + ParsedDataValue, ParsedDataNumeric, OrdinalNumber, DimensionUserOuput, ModelOption } from '../util/types'; import {parseDate} from '../util/number'; import {isDataItemOption} from '../util/model'; @@ -931,7 +931,7 @@ class List { * @param value ordinal index * @return rawIndex */ - rawIndexOf(dim: DimensionName, value: OrdinalRawValueIndex): number { + rawIndexOf(dim: DimensionName, value: OrdinalNumber): number { var invertedIndices = dim && this._invertedIndicesMap[dim]; if (__DEV__) { if (!invertedIndices) { @@ -1933,7 +1933,7 @@ class List { val = chunk[chunkOffset]; var ordinalMeta = list._dimensionInfos[dim].ordinalMeta; if (ordinalMeta && ordinalMeta.categories.length) { - val = ordinalMeta.categories[val as OrdinalRawValueIndex]; + val = ordinalMeta.categories[val as OrdinalNumber]; } } } diff --git a/src/data/OrdinalMeta.ts b/src/data/OrdinalMeta.ts index 5beb8a1..a387ce9 100644 --- a/src/data/OrdinalMeta.ts +++ b/src/data/OrdinalMeta.ts @@ -19,20 +19,22 @@ import {createHashMap, isObject, map, HashMap} from 'zrender/src/core/util'; import Model from '../model/Model'; +import { OrdinalNumber, OrdinalRawValue } from '../util/types'; + class OrdinalMeta { - readonly categories: string[]; + readonly categories: OrdinalRawValue[]; private _needCollect: boolean; private _deduplication: boolean; - private _map: HashMap<number>; + private _map: HashMap<OrdinalNumber>; constructor(opt: { - categories?: string[], + categories?: OrdinalRawValue[], needCollect?: boolean deduplication?: boolean }) { @@ -54,14 +56,14 @@ class OrdinalMeta { }); }; - getOrdinal(category: string): number { + getOrdinal(category: OrdinalRawValue): OrdinalNumber { return this._getOrCreateMap().get(category); } /** * @return The ordinal. If not found, return NaN. */ - parseAndCollect(category: any): number { + parseAndCollect(category: OrdinalRawValue | OrdinalNumber): OrdinalNumber { var index; var needCollect = this._needCollect; @@ -106,9 +108,9 @@ class OrdinalMeta { } // Consider big data, do not create map until needed. - private _getOrCreateMap(): HashMap<number> { + private _getOrCreateMap(): HashMap<OrdinalNumber> { return this._map || ( - this._map = createHashMap<number>(this.categories) + this._map = createHashMap(this.categories) ); } } diff --git a/src/scale/Interval.ts b/src/scale/Interval.ts index 1fd3fbc..27c65f7 100644 --- a/src/scale/Interval.ts +++ b/src/scale/Interval.ts @@ -17,13 +17,6 @@ * under the License. */ -// @ts-nocheck - -/** - * Interval scale - * @module echarts/scale/Interval - */ - import * as numberUtil from '../util/number'; import * as formatUtil from '../util/format'; @@ -32,67 +25,59 @@ import * as helper from './helper'; var roundNumber = numberUtil.round; -/** - * @alias module:echarts/coord/scale/Interval - * @constructor - */ -var IntervalScale = Scale.extend({ +class IntervalScale extends Scale { - type: 'interval', + static type = 'interval'; - _interval: 0, + // Step is calculated in adjustExtent. + protected _interval: number = 0; + protected _niceExtent: [number, number]; + private _intervalPrecision: number = 2; - _intervalPrecision: 2, - setExtent: function (start, end) { + setExtent(start: number | string, end: number | string): void { var thisExtent = this._extent; - //start,end may be a Number like '25',so... - if (!isNaN(start)) { - thisExtent[0] = parseFloat(start); + // start,end may be a Number like '25',so... + if (!isNaN(start as any)) { + thisExtent[0] = parseFloat(start as any); } - if (!isNaN(end)) { - thisExtent[1] = parseFloat(end); + if (!isNaN(end as any)) { + thisExtent[1] = parseFloat(end as any); } - }, + } - unionExtent: function (other) { + unionExtent(other: [number, number]): void { var extent = this._extent; other[0] < extent[0] && (extent[0] = other[0]); other[1] > extent[1] && (extent[1] = other[1]); // unionExtent may called by it's sub classes - IntervalScale.prototype.setExtent.call(this, extent[0], extent[1]); - }, - /** - * Get interval - */ - getInterval: function () { + this.setExtent(extent[0], extent[1]); + } + + getInterval(): number { return this._interval; - }, + } - /** - * Set interval - */ - setInterval: function (interval) { + setInterval(interval: number): void { this._interval = interval; // Dropped auto calculated niceExtent and use user setted extent // We assume user wan't to set both interval, min, max to get a better result - this._niceExtent = this._extent.slice(); + this._niceExtent = this._extent.slice() as [number, number]; this._intervalPrecision = helper.getIntervalPrecision(interval); - }, + } /** - * @param {boolean} [expandToNicedExtent=false] If expand the ticks to niced extent. - * @return {Array.<number>} + * @param expandToNicedExtent Whether expand the ticks to niced extent. */ - getTicks: function (expandToNicedExtent) { + getTicks(expandToNicedExtent: boolean): number[] { var interval = this._interval; var extent = this._extent; var niceTickExtent = this._niceExtent; var intervalPrecision = this._intervalPrecision; - var ticks = []; + var ticks = [] as number[]; // If interval is 0, return []; if (!interval) { return ticks; @@ -137,13 +122,9 @@ var IntervalScale = Scale.extend({ } return ticks; - }, + } - /** - * @param {number} [splitNumber=5] - * @return {Array.<Array.<number>>} - */ - getMinorTicks: function (splitNumber) { + getMinorTicks(splitNumber: number): number[][] { var ticks = this.getTicks(true); var minorTicks = []; var extent = this.getExtent(); @@ -157,7 +138,7 @@ var IntervalScale = Scale.extend({ var minorInterval = interval / splitNumber; while (count < splitNumber - 1) { - var minorTick = numberUtil.round(prevTick + (count + 1) * minorInterval); + var minorTick = roundNumber(prevTick + (count + 1) * minorInterval); // For the first and last interval. The count may be less than splitNumber. if (minorTick > extent[0] && minorTick < extent[1]) { @@ -169,16 +150,19 @@ var IntervalScale = Scale.extend({ } return minorTicks; - }, + } /** - * @param {number} data - * @param {Object} [opt] - * @param {number|string} [opt.precision] If 'auto', use nice presision. - * @param {boolean} [opt.pad] returns 1.50 but not 1.5 if precision is 2. - * @return {string} + * @param opt.precision If 'auto', use nice presision. + * @param opt.pad returns 1.50 but not 1.5 if precision is 2. */ - getLabel: function (data, opt) { + getLabel( + data: number, + opt?: { + precision?: 'auto' | number, + pad?: boolean + } + ): string { if (data == null) { return ''; } @@ -195,19 +179,15 @@ var IntervalScale = Scale.extend({ // (1) If `precision` is set, 12.005 should be display as '12.00500'. // (2) Use roundNumber (toFixed) to avoid scientific notation like '3.5e-7'. - data = roundNumber(data, precision, true); + var dataNum = roundNumber(data, precision as number, true); - return formatUtil.addCommas(data); - }, + return formatUtil.addCommas(dataNum); + } /** - * Update interval and extent of intervals for nice ticks - * - * @param {number} [splitNumber = 5] Desired number of ticks - * @param {number} [minInterval] - * @param {number} [maxInterval] + * @param splitNumber By default `5`. */ - niceTicks: function (splitNumber, minInterval, maxInterval) { + niceTicks(splitNumber?: number, minInterval?: number, maxInterval?: number): void { splitNumber = splitNumber || 5; var extent = this._extent; var span = extent[1] - extent[0]; @@ -228,18 +208,15 @@ var IntervalScale = Scale.extend({ this._intervalPrecision = result.intervalPrecision; this._interval = result.interval; this._niceExtent = result.niceTickExtent; - }, + } - /** - * Nice extent. - * @param {Object} opt - * @param {number} [opt.splitNumber = 5] Given approx tick number - * @param {boolean} [opt.fixMin=false] - * @param {boolean} [opt.fixMax=false] - * @param {boolean} [opt.minInterval] - * @param {boolean} [opt.maxInterval] - */ - niceExtent: function (opt) { + niceExtent(opt: { + splitNumber: number, // By default 5. + fixMin?: boolean, + fixMax?: boolean, + minInterval?: number, + maxInterval?: number + }): void { var extent = this._extent; // If extent start and end are same, expand them if (extent[0] === extent[1]) { @@ -282,13 +259,9 @@ var IntervalScale = Scale.extend({ extent[1] = roundNumber(Math.ceil(extent[1] / interval) * interval); } } -}); -/** - * @return {module:echarts/scale/Time} - */ -IntervalScale.create = function () { - return new IntervalScale(); -}; +} + +Scale.registerClass(IntervalScale); -export default IntervalScale; \ No newline at end of file +export default IntervalScale; diff --git a/src/scale/Log.ts b/src/scale/Log.ts index 9f28d3c..4349f36 100644 --- a/src/scale/Log.ts +++ b/src/scale/Log.ts @@ -17,21 +17,17 @@ * under the License. */ -// @ts-nocheck - -/** - * Log scale - * @module echarts/scale/Log - */ - import * as zrUtil from 'zrender/src/core/util'; import Scale from './Scale'; import * as numberUtil from '../util/number'; // Use some method of IntervalScale import IntervalScale from './Interval'; +import List from '../data/List'; +import { DimensionName } from '../util/types'; var scaleProto = Scale.prototype; +// FIXME:TS refactor: not good to call it directly with `this`? var intervalScaleProto = IntervalScale.prototype; var getPrecisionSafe = numberUtil.getPrecisionSafe; @@ -43,77 +39,63 @@ var mathPow = Math.pow; var mathLog = Math.log; -var LogScale = Scale.extend({ +class LogScale extends Scale { + + static type = 'log'; - type: 'log', + private base = 10; - base: 10, + private _originalScale: IntervalScale = new IntervalScale(); - $constructor: function () { - Scale.apply(this, arguments); - this._originalScale = new IntervalScale(); - }, + private _fixMin: boolean; + private _fixMax: boolean; + + // FIXME:TS actually used by `IntervalScale` + private _interval: number = 0; + // FIXME:TS actually used by `IntervalScale` + private _niceExtent: [number, number]; /** - * @param {boolean} [expandToNicedExtent=false] If expand the ticks to niced extent. - * @return {Array.<number>} + * @param Whether expand the ticks to niced extent. */ - getTicks: function (expandToNicedExtent) { + getTicks(expandToNicedExtent: boolean): number[] { var originalScale = this._originalScale; var extent = this._extent; var originalExtent = originalScale.getExtent(); - return zrUtil.map(intervalScaleProto.getTicks.call(this, expandToNicedExtent), function (val) { + var ticks = intervalScaleProto.getTicks.call(this, expandToNicedExtent); + + return zrUtil.map(ticks, function (val) { var powVal = numberUtil.round(mathPow(this.base, val)); // Fix #4158 - powVal = (val === extent[0] && originalScale.__fixMin) + powVal = (val === extent[0] && this._fixMin) ? fixRoundingError(powVal, originalExtent[0]) : powVal; - powVal = (val === extent[1] && originalScale.__fixMax) + powVal = (val === extent[1] && this._fixMax) ? fixRoundingError(powVal, originalExtent[1]) : powVal; return powVal; }, this); - }, - - /** - * @param {number} splitNumber - * @return {Array.<Array.<number>>} - */ - getMinorTicks: intervalScaleProto.getMinorTicks, - - /** - * @param {number} val - * @return {string} - */ - getLabel: intervalScaleProto.getLabel, + } - /** - * @param {number} val - * @return {number} - */ - scale: function (val) { - val = scaleProto.scale.call(this, val); + scale(val: number): number { + val = super.scale(val); return mathPow(this.base, val); - }, + } - /** - * @param {number} start - * @param {number} end - */ - setExtent: function (start, end) { + setExtent(start: number, end: number): void { var base = this.base; start = mathLog(start) / mathLog(base); end = mathLog(end) / mathLog(base); intervalScaleProto.setExtent.call(this, start, end); - }, + } /** * @return {number} end */ - getExtent: function () { + getExtent() { var base = this.base; var extent = scaleProto.getExtent.call(this); extent[0] = mathPow(base, extent[0]); @@ -122,38 +104,32 @@ var LogScale = Scale.extend({ // Fix #4158 var originalScale = this._originalScale; var originalExtent = originalScale.getExtent(); - originalScale.__fixMin && (extent[0] = fixRoundingError(extent[0], originalExtent[0])); - originalScale.__fixMax && (extent[1] = fixRoundingError(extent[1], originalExtent[1])); + this._fixMin && (extent[0] = fixRoundingError(extent[0], originalExtent[0])); + this._fixMax && (extent[1] = fixRoundingError(extent[1], originalExtent[1])); return extent; - }, + } - /** - * @param {Array.<number>} extent - */ - unionExtent: function (extent) { + unionExtent(extent: [number, number]): void { this._originalScale.unionExtent(extent); var base = this.base; extent[0] = mathLog(extent[0]) / mathLog(base); extent[1] = mathLog(extent[1]) / mathLog(base); scaleProto.unionExtent.call(this, extent); - }, + } - /** - * @override - */ - unionExtentFromData: function (data, dim) { + unionExtentFromData(data: List, dim: DimensionName): void { // TODO // filter value that <= 0 this.unionExtent(data.getApproximateExtent(dim)); - }, + } /** * Update interval and extent of intervals for nice ticks - * @param {number} [approxTickNum = 10] Given approx tick number + * @param approxTickNum default 10 Given approx tick number */ - niceTicks: function (approxTickNum) { + niceTicks(approxTickNum: number): void { approxTickNum = approxTickNum || 10; var extent = this._extent; var span = extent[1] - extent[0]; @@ -177,39 +153,46 @@ var LogScale = Scale.extend({ var niceExtent = [ numberUtil.round(mathCeil(extent[0] / interval) * interval), numberUtil.round(mathFloor(extent[1] / interval) * interval) - ]; + ] as [number, number]; this._interval = interval; this._niceExtent = niceExtent; - }, + } - /** - * Nice extent. - * @override - */ - niceExtent: function (opt) { + niceExtent(opt: { + splitNumber: number, // By default 5. + fixMin?: boolean, + fixMax?: boolean, + minInterval?: number, + maxInterval?: number + }): void { intervalScaleProto.niceExtent.call(this, opt); - var originalScale = this._originalScale; - originalScale.__fixMin = opt.fixMin; - originalScale.__fixMax = opt.fixMax; + this._fixMin = opt.fixMin; + this._fixMax = opt.fixMax; } -}); + contain(val: number): boolean { + val = mathLog(val) / mathLog(this.base); + return super.contain(val); + } -zrUtil.each(['contain', 'normalize'], function (methodName) { - LogScale.prototype[methodName] = function (val) { + normalize(val: number): number { val = mathLog(val) / mathLog(this.base); - return scaleProto[methodName].call(this, val); - }; -}); + return super.normalize(val); + } + + getMinorTicks: IntervalScale['getMinorTicks']; + getLabel: IntervalScale['getLabel']; +} + +var proto = LogScale.prototype; +proto.getMinorTicks = intervalScaleProto.getMinorTicks; +proto.getLabel = intervalScaleProto.getLabel; -LogScale.create = function () { - return new LogScale(); -}; -function fixRoundingError(val, originalVal) { +function fixRoundingError(val: number, originalVal: number): number { return roundingErrorFix(val, getPrecisionSafe(originalVal)); } -export default LogScale; \ No newline at end of file +export default LogScale; diff --git a/src/scale/Ordinal.ts b/src/scale/Ordinal.ts index 4eae3db..05ee404 100644 --- a/src/scale/Ordinal.ts +++ b/src/scale/Ordinal.ts @@ -17,12 +17,8 @@ * under the License. */ -// @ts-nocheck - /** * Linear continuous scale - * @module echarts/coord/scale/Ordinal - * * http://en.wikipedia.org/wiki/Level_of_measurement */ @@ -31,56 +27,58 @@ import * as zrUtil from 'zrender/src/core/util'; import Scale from './Scale'; import OrdinalMeta from '../data/OrdinalMeta'; +import List from '../data/List'; +import { OrdinalRawValue, OrdinalNumber, DimensionLoose } from '../util/types'; -var scaleProto = Scale.prototype; -var OrdinalScale = Scale.extend({ +class OrdinalScale extends Scale { - type: 'ordinal', + static type: 'ordinal'; - /** - * @param {module:echarts/data/OrdianlMeta|Array.<string>} ordinalMeta - */ - init: function (ordinalMeta, extent) { + private _ordinalMeta: OrdinalMeta; + + + constructor(setting?: { + ordinalMeta?: OrdinalMeta | OrdinalRawValue[], + extent?: [number, number] + }) { + super(setting); + + var ordinalMeta = this.getSetting('ordinalMeta'); // Caution: Should not use instanceof, consider ec-extensions using // import approach to get OrdinalMeta class. if (!ordinalMeta || zrUtil.isArray(ordinalMeta)) { ordinalMeta = new OrdinalMeta({categories: ordinalMeta}); } this._ordinalMeta = ordinalMeta; - this._extent = extent || [0, ordinalMeta.categories.length - 1]; - }, + this._extent = this.getSetting('extent') || [0, ordinalMeta.categories.length - 1]; + } - parse: function (val) { + parse(val: OrdinalRawValue | OrdinalNumber): OrdinalNumber { return typeof val === 'string' ? this._ordinalMeta.getOrdinal(val) // val might be float. : Math.round(val); - }, + } - contain: function (rank) { + contain(rank: OrdinalRawValue | OrdinalNumber): boolean { rank = this.parse(rank); - return scaleProto.contain.call(this, rank) + return super.contain(rank) && this._ordinalMeta.categories[rank] != null; - }, + } /** * Normalize given rank or name to linear [0, 1] - * @param {number|string} [val] - * @return {number} */ - normalize: function (val) { - return scaleProto.normalize.call(this, this.parse(val)); - }, + normalize(val: OrdinalRawValue | OrdinalNumber): number { + return super.normalize(this.parse(val)); + } - scale: function (val) { - return Math.round(scaleProto.scale.call(this, val)); - }, + scale(val: number): OrdinalNumber { + return Math.round(super.scale(val)); + } - /** - * @return {Array} - */ - getTicks: function () { + getTicks(): OrdinalNumber[] { var ticks = []; var extent = this._extent; var rank = extent[0]; @@ -91,47 +89,41 @@ var OrdinalScale = Scale.extend({ } return ticks; - }, + } + + getMinorTicks(splitNumber: number): number[][] { + // Not support. + return; + } /** * Get item on rank n - * @param {number} n - * @return {string} */ - getLabel: function (n) { + getLabel(n: OrdinalNumber): string { if (!this.isBlank()) { // Note that if no data, ordinalMeta.categories is an empty array. - return this._ordinalMeta.categories[n]; + return this._ordinalMeta.categories[n] + ''; } - }, + } - /** - * @return {number} - */ - count: function () { + count(): number { return this._extent[1] - this._extent[0] + 1; - }, + } - /** - * @override - */ - unionExtentFromData: function (data, dim) { + unionExtentFromData(data: List, dim: DimensionLoose) { this.unionExtent(data.getApproximateExtent(dim)); - }, + } - getOrdinalMeta: function () { + getOrdinalMeta(): OrdinalMeta { return this._ordinalMeta; - }, + } - niceTicks: zrUtil.noop, - niceExtent: zrUtil.noop -}); + niceTicks() {} -/** - * @return {module:echarts/scale/Time} - */ -OrdinalScale.create = function () { - return new OrdinalScale(); -}; + niceExtent() {} + +} + +Scale.registerClass(OrdinalScale); -export default OrdinalScale; \ No newline at end of file +export default OrdinalScale; diff --git a/src/scale/Scale.ts b/src/scale/Scale.ts index 5203002..a58c26f 100644 --- a/src/scale/Scale.ts +++ b/src/scale/Scale.ts @@ -17,153 +17,160 @@ * under the License. */ -// @ts-nocheck - -/** - * // Scale class management - * @module echarts/scale/Scale - */ import * as clazzUtil from '../util/clazz'; +import { Dictionary } from 'zrender/src/core/types'; +import List from '../data/List'; +import { DimensionName } from '../util/types'; + + +abstract class Scale { + + private _setting: Dictionary<any>; -/** - * @param {Object} [setting] - */ -function Scale(setting) { - this._setting = setting || {}; + protected _extent: [number, number]; + + private _isBlank: boolean; + + constructor(setting?: Dictionary<any>) { + this._setting = setting || {}; + this._extent = [Infinity, -Infinity]; + } /** - * Extent - * @type {Array.<number>} - * @protected + * Parse input val to valid inner number. */ - this._extent = [Infinity, -Infinity]; + parse(val: any): any { + // Notice: This would be a trap here, If the implementation + // of this method depends on extent, and this method is used + // before extent set (like in dataZoom), it would be wrong. + // Nevertheless, parse does not depend on extent generally. + return val; + } + + getSetting(name: string): any { + return this._setting[name]; + } + + contain(val: number): boolean { + var extent = this._extent; + return val >= extent[0] && val <= extent[1]; + } /** - * Step is calculated in adjustExtent - * @type {Array.<number>} - * @protected + * Normalize value to linear [0, 1], return 0.5 if extent span is 0 */ - this._interval = 0; + normalize(val: number): number { + var extent = this._extent; + if (extent[1] === extent[0]) { + return 0.5; + } + return (val - extent[0]) / (extent[1] - extent[0]); + } - this.init && this.init.apply(this, arguments); -} + /** + * Scale normalized value + */ + scale(val: number): number { + var extent = this._extent; + return val * (extent[1] - extent[0]) + extent[0]; + } -/** - * Parse input val to valid inner number. - * @param {*} val - * @return {number} - */ -Scale.prototype.parse = function (val) { - // Notice: This would be a trap here, If the implementation - // of this method depends on extent, and this method is used - // before extent set (like in dataZoom), it would be wrong. - // Nevertheless, parse does not depend on extent generally. - return val; -}; - -Scale.prototype.getSetting = function (name) { - return this._setting[name]; -}; - -Scale.prototype.contain = function (val) { - var extent = this._extent; - return val >= extent[0] && val <= extent[1]; -}; - -/** - * Normalize value to linear [0, 1], return 0.5 if extent span is 0 - * @param {number} val - * @return {number} - */ -Scale.prototype.normalize = function (val) { - var extent = this._extent; - if (extent[1] === extent[0]) { - return 0.5; + /** + * Set extent from data + */ + unionExtent(other: [number, number]): void { + var extent = this._extent; + other[0] < extent[0] && (extent[0] = other[0]); + other[1] > extent[1] && (extent[1] = other[1]); + // not setExtent because in log axis it may transformed to power + // this.setExtent(extent[0], extent[1]); } - return (val - extent[0]) / (extent[1] - extent[0]); -}; - -/** - * Scale normalized value - * @param {number} val - * @return {number} - */ -Scale.prototype.scale = function (val) { - var extent = this._extent; - return val * (extent[1] - extent[0]) + extent[0]; -}; - -/** - * Set extent from data - * @param {Array.<number>} other - */ -Scale.prototype.unionExtent = function (other) { - var extent = this._extent; - other[0] < extent[0] && (extent[0] = other[0]); - other[1] > extent[1] && (extent[1] = other[1]); - // not setExtent because in log axis it may transformed to power - // this.setExtent(extent[0], extent[1]); -}; - -/** - * Set extent from data - * @param {module:echarts/data/List} data - * @param {string} dim - */ -Scale.prototype.unionExtentFromData = function (data, dim) { - this.unionExtent(data.getApproximateExtent(dim)); -}; - -/** - * Get extent - * @return {Array.<number>} - */ -Scale.prototype.getExtent = function () { - return this._extent.slice(); -}; - -/** - * Set extent - * @param {number} start - * @param {number} end - */ -Scale.prototype.setExtent = function (start, end) { - var thisExtent = this._extent; - if (!isNaN(start)) { - thisExtent[0] = start; + + /** + * Set extent from data + */ + unionExtentFromData(data: List, dim: DimensionName): void { + this.unionExtent(data.getApproximateExtent(dim)); } - if (!isNaN(end)) { - thisExtent[1] = end; + + /** + * Get extent + */ + getExtent(): [number, number] { + return this._extent.slice() as [number, number]; } -}; - -/** - * When axis extent depends on data and no data exists, - * axis ticks should not be drawn, which is named 'blank'. - */ -Scale.prototype.isBlank = function () { - return this._isBlank; -}, - -/** - * When axis extent depends on data and no data exists, - * axis ticks should not be drawn, which is named 'blank'. - */ -Scale.prototype.setBlank = function (isBlank) { - this._isBlank = isBlank; -}; - -/** - * @abstract - * @param {*} tick - * @return {string} label of the tick. - */ -Scale.prototype.getLabel = null; - - -clazzUtil.enableClassExtend(Scale); -clazzUtil.enableClassManagement(Scale, { + + /** + * Set extent + */ + setExtent(start: number, end: number): void { + var thisExtent = this._extent; + if (!isNaN(start)) { + thisExtent[0] = start; + } + if (!isNaN(end)) { + thisExtent[1] = end; + } + } + + /** + * When axis extent depends on data and no data exists, + * axis ticks should not be drawn, which is named 'blank'. + */ + isBlank(): boolean { + return this._isBlank; + } + + /** + * When axis extent depends on data and no data exists, + * axis ticks should not be drawn, which is named 'blank'. + */ + setBlank(isBlank: boolean) { + this._isBlank = isBlank; + } + + /** + * Update interval and extent of intervals for nice ticks + * + * @param splitNumber Approximated tick numbers. Optional. + * The implementation of `niceTicks` should decide tick numbers + * whether `splitNumber` is given. + * @param minInterval Optional. + * @param maxInterval Optional. + */ + abstract niceTicks( + // FIXME:TS make them in a "opt", the same with `niceExtent`? + splitNumber?: number, + minInterval?: number, + maxInterval?: number + ): void; + + abstract niceExtent( + opt?: { + splitNumber?: number, + fixMin?: boolean, + fixMax?: boolean, + minInterval?: number, + maxInterval?: number + } + ): void; + + /** + * @return label of the tick. + */ + abstract getLabel(tick: any): string; + + abstract getTicks(expandToNicedExtent: boolean): number[]; + + abstract getMinorTicks(splitNumber: number): number[][]; + + static registerClass: clazzUtil.ClassManager['registerClass']; + +} + +type ScaleConstructor = typeof Scale & clazzUtil.ClassManager; +clazzUtil.enableClassManagement(Scale as ScaleConstructor, { registerWhenExtend: true }); diff --git a/src/scale/Time.ts b/src/scale/Time.ts index 11aaa52..8709c57 100644 --- a/src/scale/Time.ts +++ b/src/scale/Time.ts @@ -17,8 +17,6 @@ * under the License. */ -// @ts-nocheck - /* * A third-party license is embeded for some of the code in this file: * The "scaleLevels" was originally copied from "d3.js" with some @@ -40,13 +38,12 @@ // (2) By default, the input data string (e.g., '2011-01-02') should be displayed // as its original time, without any time difference. -import * as zrUtil from 'zrender/src/core/util'; import * as numberUtil from '../util/number'; import * as formatUtil from '../util/format'; import * as scaleHelper from './helper'; import IntervalScale from './Interval'; +import Model from '../model/Model'; -var intervalScaleProto = IntervalScale.prototype; var mathCeil = Math.ceil; var mathFloor = Math.floor; @@ -56,7 +53,12 @@ var ONE_HOUR = ONE_MINUTE * 60; var ONE_DAY = ONE_HOUR * 24; // FIXME 公用？ -var bisect = function (a, x, lo, hi) { +var bisect = function ( + a: [string, number][], + x: number, + lo: number, + hi: number +): number { while (lo < hi) { var mid = lo + hi >>> 1; if (a[mid][1] < x) { @@ -69,28 +71,30 @@ var bisect = function (a, x, lo, hi) { return lo; }; -/** - * @alias module:echarts/coord/scale/Time - * @constructor - */ -var TimeScale = IntervalScale.extend({ - type: 'time', - /** - * @override - */ - getLabel: function (val) { +class TimeScale extends IntervalScale { + + static type = 'time'; + + private _stepLvl: [string, number]; + + getLabel(val: number): string { var stepLvl = this._stepLvl; var date = new Date(val); return formatUtil.formatTime(stepLvl[0], date, this.getSetting('useUTC')); - }, + } - /** - * @override - */ - niceExtent: function (opt) { + niceExtent( + opt?: { + splitNumber?: number, + fixMin?: boolean, + fixMax?: boolean, + minInterval?: number, + maxInterval?: number + } + ): void { var extent = this._extent; // If extent start and end are same, expand them if (extent[0] === extent[1]) { @@ -116,12 +120,9 @@ var TimeScale = IntervalScale.extend({ if (!opt.fixMax) { extent[1] = numberUtil.round(mathCeil(extent[1] / interval) * interval); } - }, + } - /** - * @override - */ - niceTicks: function (approxTickNum, minInterval, maxInterval) { + niceTicks(approxTickNum: number, minInterval: number, maxInterval: number): void { approxTickNum = approxTickNum || 10; var extent = this._extent; @@ -156,7 +157,7 @@ var TimeScale = IntervalScale.extend({ var niceExtent = [ Math.round(mathCeil((extent[0] - timezoneOffset) / interval) * interval + timezoneOffset), Math.round(mathFloor((extent[1] - timezoneOffset) / interval) * interval + timezoneOffset) - ]; + ] as [number, number]; scaleHelper.fixExtent(niceExtent, extent); @@ -164,19 +165,23 @@ var TimeScale = IntervalScale.extend({ // Interval will be used in getTicks this._interval = interval; this._niceExtent = niceExtent; - }, + } - parse: function (val) { + parse(val: any): number { // val might be float. return +numberUtil.parseDate(val); } -}); -zrUtil.each(['contain', 'normalize'], function (methodName) { - TimeScale.prototype[methodName] = function (val) { - return intervalScaleProto[methodName].call(this, this.parse(val)); - }; -}); + contain(val: number): boolean { + return super.contain(this.parse(val)); + } + + normalize(val: number): number { + return super.normalize(this.parse(val)); + } + +} + /** * This implementation was originally copied from "d3.js" @@ -221,14 +226,7 @@ var scaleLevels = [ ['month', ONE_DAY * 31 * 8], // 8M ['month', ONE_DAY * 31 * 10], // 10M ['year', ONE_DAY * 380] // 1Y -]; +] as [string, number][]; -/** - * @param {module:echarts/model/Model} - * @return {module:echarts/scale/Time} - */ -TimeScale.create = function (model) { - return new TimeScale({useUTC: model.ecModel.get('useUTC')}); -}; -export default TimeScale; \ No newline at end of file +export default TimeScale; diff --git a/src/scale/helper.ts b/src/scale/helper.ts index bd8be72..3af512c 100644 --- a/src/scale/helper.ts +++ b/src/scale/helper.ts @@ -17,28 +17,30 @@ * under the License. */ -// @ts-nocheck - -/** - * For testable. - */ - import * as numberUtil from '../util/number'; var roundNumber = numberUtil.round; +type intervalScaleNiceTicksResult = { + interval: number, + intervalPrecision: number, + niceTickExtent: [number, number] +}; /** - * @param {Array.<number>} extent Both extent[0] and extent[1] should be valid number. - * Should be extent[0] < extent[1]. - * @param {number} splitNumber splitNumber should be >= 1. - * @param {number} [minInterval] - * @param {number} [maxInterval] - * @return {Object} {interval, intervalPrecision, niceTickExtent} + * @param extent Both extent[0] and extent[1] should be valid number. + * Should be extent[0] < extent[1]. + * @param splitNumber splitNumber should be >= 1. */ -export function intervalScaleNiceTicks(extent, splitNumber, minInterval, maxInterval) { - var result = {}; - var span = extent[1] - extent[0]; +export function intervalScaleNiceTicks( + extent: [number, number], + splitNumber: number, + minInterval?: number, + maxInterval?: number +): intervalScaleNiceTicksResult { + + var result = {} as intervalScaleNiceTicksResult; + var span = extent[1] - extent[0]; var interval = result.interval = numberUtil.nice(span / splitNumber, true); if (minInterval != null && interval < minInterval) { interval = result.interval = minInterval; @@ -60,20 +62,23 @@ export function intervalScaleNiceTicks(extent, splitNumber, minInterval, maxInte } /** - * @param {number} interval - * @return {number} interval precision + * @return interval precision */ -export function getIntervalPrecision(interval) { +export function getIntervalPrecision(interval: number): number { // Tow more digital for tick. return numberUtil.getPrecisionSafe(interval) + 2; } -function clamp(niceTickExtent, idx, extent) { +function clamp( + niceTickExtent: [number, number], idx: number, extent: [number, number] +): void { niceTickExtent[idx] = Math.max(Math.min(niceTickExtent[idx], extent[1]), extent[0]); } // In some cases (e.g., splitNumber is 1), niceTickExtent may be out of extent. -export function fixExtent(niceTickExtent, extent) { +export function fixExtent( + niceTickExtent: [number, number], extent: [number, number] +): void { !isFinite(niceTickExtent[0]) && (niceTickExtent[0] = extent[0]); !isFinite(niceTickExtent[1]) && (niceTickExtent[1] = extent[1]); clamp(niceTickExtent, 0, extent); @@ -81,4 +86,4 @@ export function fixExtent(niceTickExtent, extent) { if (niceTickExtent[0] > niceTickExtent[1]) { niceTickExtent[0] = niceTickExtent[1]; } -} \ No newline at end of file +} diff --git a/src/util/format.ts b/src/util/format.ts index 54b630c..fc1548d 100644 --- a/src/util/format.ts +++ b/src/util/format.ts @@ -196,7 +196,7 @@ function pad(str: string, len: number): string { * and `module:echarts/util/number#parseDate`. * @inner */ -export function formatTime(tpl: string, value: number, isUTC?: boolean) { +export function formatTime(tpl: string, value: number | string | Date, isUTC?: boolean) { if (tpl === 'week' || tpl === 'month' || tpl === 'quarter' diff --git a/src/util/number.ts b/src/util/number.ts index ca6ee67..1a9d0ba 100644 --- a/src/util/number.ts +++ b/src/util/number.ts @@ -125,14 +125,17 @@ export function parsePercent(percent: number | string, all: number): number { * (1) Fix rounding error of float numbers. * (2) Support return string to avoid scientific notation like '3.5e-7'. */ -export function round(x: number | string, precision: number, returnStr?: boolean): string | number { +export function round(x: number | string, precision?: number): number; +export function round(x: number | string, precision: number, returnStr: false): number; +export function round(x: number | string, precision: number, returnStr: true): string; +export function round(x: number | string, precision?: number, returnStr?: boolean): string | number { if (precision == null) { precision = 10; } // Avoid range error precision = Math.min(Math.max(0, precision), 20); x = (+x).toFixed(precision); - return returnStr ? x : +x; + return (returnStr ? x : +x); } /** diff --git a/src/util/types.ts b/src/util/types.ts index 53509a3..6e7bb35 100644 --- a/src/util/types.ts +++ b/src/util/types.ts @@ -61,7 +61,9 @@ export type ZRFontWeight = 'normal' | 'bold' | 'bolder' | 'lighter' | number export type ZREasing = easingType -// Actually ComponentFullType is ComponentMainType.ComponentSubType +// ComponentFullType can be: +// 'xxx.yyy': means ComponentMainType.ComponentSubType. +// 'xxx': means ComponentMainType. // See `checkClassType` check the restict definition. export type ComponentFullType = string; export type ComponentMainType = keyof ECUnitOption & string; @@ -221,9 +223,9 @@ export type TooltipRenderMode = 'html' | 'richText'; // Ordinal/category data will be parsed to its index if possible, otherwise // keep its original string in list._storage. // Check `convertDataValue` for more details. -export type OrdinalRawValue = string; -export type OrdinalRawValueIndex = number; -export type ParsedDataNumeric = number | OrdinalRawValueIndex; +export type OrdinalRawValue = string | number; +export type OrdinalNumber = number; // The number mapped from each OrdinalRawValue. +export type ParsedDataNumeric = number | OrdinalNumber; export type ParsedDataValue = ParsedDataNumeric | OrdinalRawValue; export type AxisValue = ParsedDataNumeric; diff --git a/test/build/test-transform.js b/test/build/test-transform.js index 2eaa334..55e0396 100644 --- a/test/build/test-transform.js +++ b/test/build/test-transform.js @@ -22,7 +22,7 @@ const path = require('path'); const babel = require('@babel/core'); const fs = require('fs'); // See require('@babel/plugin-transform-modules-commonjs') -const esm2cjsPlugin = path.resolve(__dirname, '../../build/babel-plugin-transform-modules-commonjs-ec'); +// const esm2cjsPlugin = path.resolve(__dirname, '../../build/babel-plugin-transform-modules-commonjs-ec'); const removeDEVPlugin = path.resolve(__dirname, '../../build/babel-plugin-transform-remove-dev'); function run() { @@ -69,7 +69,8 @@ function esm2cjs() { function transformSingle() { let result = babel.transformFileSync(filePath, { - plugins: [removeDEVPlugin, esm2cjsPlugin] + // plugins: [removeDEVPlugin, esm2cjsPlugin] + plugins: [removeDEVPlugin] }); suite.writeToExpectFile(fileName, result.code); --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
