You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@echarts.apache.org by su...@apache.org on 2020/02/19 22:17:19 UTC
[incubator-echarts] branch typescript updated (ab16b5a -> d69ffcd)
This is an automated email from the ASF dual-hosted git repository.
sushuang pushed a change to branch typescript
in repository https://gitbox.apache.org/repos/asf/incubator-echarts.git.
from ab16b5a ts: add types for Graph and Tree data structure
new d67bfd2 tiny fix
new d69ffcd 'scale' to ts
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
src/coord/axisHelper.ts | 19 +--
src/data/Graph.ts | 9 --
src/data/List.ts | 6 +-
src/data/OrdinalMeta.ts | 16 +--
src/data/Tree.ts | 5 +-
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 +-
15 files changed, 420 insertions(+), 457 deletions(-)
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@echarts.apache.org
For additional commands, e-mail: commits-help@echarts.apache.org
[incubator-echarts] 02/02: 'scale' to ts
Posted by su...@apache.org.
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 <su...@gmail.com>
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: commits-unsubscribe@echarts.apache.org
For additional commands, e-mail: commits-help@echarts.apache.org
[incubator-echarts] 01/02: tiny fix
Posted by su...@apache.org.
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 d67bfd228651fa06587976c4a9ffe0a86bd7871e
Author: 100pah <su...@gmail.com>
AuthorDate: Thu Feb 20 01:57:14 2020 +0800
tiny fix
---
src/data/Graph.ts | 9 ---------
src/data/Tree.ts | 5 ++++-
2 files changed, 4 insertions(+), 10 deletions(-)
diff --git a/src/data/Graph.ts b/src/data/Graph.ts
index c78536c..20da5ab 100644
--- a/src/data/Graph.ts
+++ b/src/data/Graph.ts
@@ -342,15 +342,6 @@ class GraphNode {
constructor(id?: string, dataIndex?: number) {
this.id = id == null ? '' : id;
-
- this.inEdges = [];
-
- this.outEdges = [];
-
- this.edges = [];
-
- this.hostGraph;
-
this.dataIndex = dataIndex == null ? -1 : dataIndex;
}
diff --git a/src/data/Tree.ts b/src/data/Tree.ts
index 1726a5c..96fdfdd 100644
--- a/src/data/Tree.ts
+++ b/src/data/Tree.ts
@@ -301,9 +301,12 @@ class Tree<HostModel extends Model, LevelOption, LeavesOption> {
leavesModel: Model<LeavesOption>
- private _nodes: TreeNode[]
+ private _nodes: TreeNode[] = []
constructor(hostModel: HostModel, levelOptions: LevelOption[], leavesOption: LeavesOption) {
+
+ this.hostModel = hostModel;
+
this.levelModels = zrUtil.map(levelOptions || [], function (levelDefine) {
return new Model(levelDefine, hostModel, hostModel.ecModel);
});
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@echarts.apache.org
For additional commands, e-mail: commits-help@echarts.apache.org