Merge pull request ecomfe#806 from ecomfe/release-dev

Fix lint.

build/progress.js

@@ -53,8 +53,13 @@ module.exports = function progress(options = {}) {
  },
 
  buildEnd() {
- process.stdout.clearLine();
- process.stdout.cursorTo(0);
+ if (process.stdout.isTTY) {
+ process.stdout.clearLine();
+ process.stdout.cursorTo(0);
+ }
+ else {
+ console.log('');
+ }
  }
  };
 };

package.json

@@ -19,7 +19,8 @@
  "build:lib": "npx tsc -m ES2015 --outDir lib",
  "watch:bundle": "node build/build.js --watch",
  "watch:lib": "npx tsc -w -m ES2015 --outDir lib",
- "test": "npx jest --config test/ut/jest.config.js"
+ "test": "npx jest --config test/ut/jest.config.js",
+ "lint": "npx eslint src/**/*.ts"
  },
  "license": "BSD-3-Clause",
  "types": "index.d.ts",

src/Element.ts

@@ -293,6 +293,7 @@ export type ElementCalculateTextPosition = (
 let tmpTextPosCalcRes = {} as TextPositionCalculationResult;
 let tmpBoundingRect = new BoundingRect(0, 0, 0, 0);
 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 interface Element<Props extends ElementProps = ElementProps> extends Transformable,
  Eventful<{
  [key in ElementEventName]: (e: ElementEvent) => void | boolean

src/PainterBase.ts

@@ -4,10 +4,10 @@ import { GradientObject } from './graphic/Gradient';
 import { PatternObject } from './graphic/Pattern';
 import { Dictionary } from './core/types';
 
-interface PainterOption {
- width?: number | string // Can be 10 / 10px / auto
- height?: number | string
-}
+// interface PainterOption {
+//  width?: number | string // Can be 10 / 10px / auto
+//  height?: number | string
+// }
 
 export interface PainterBase {
 

src/animation/Animator.ts

@@ -430,8 +430,8 @@ class Track {
  for (let i = 0; i < kfsLen; i++) {
  if (arrDim === 0) {
  if (this.isValueColor) {
- kfs[i].additiveValue
- = add1DArray([], kfs[i].value as NumberArray, startValue as NumberArray, -1);
+ kfs[i].additiveValue =
+ add1DArray([], kfs[i].value as NumberArray, startValue as NumberArray, -1);
  }
  else {
  kfs[i].additiveValue = kfs[i].value as number - (startValue as number);

src/animation/Clip.ts

@@ -21,7 +21,7 @@ type ondestroyCallback = () => void
 type onrestartCallback = () => void
 
 export type DeferredEventTypes = 'destroy' | 'restart'
-type DeferredEventKeys = 'ondestroy' | 'onrestart'
+// type DeferredEventKeys = 'ondestroy' | 'onrestart'
 
 export interface ClipProps {
  life?: number

src/config.ts

@@ -2,9 +2,11 @@ let dpr = 1;
 
 // If in browser environment
 if (typeof window !== 'undefined') {
- dpr = Math.max(window.devicePixelRatio 
- || (window.screen && (window.screen as any).deviceXDPI / (window.screen as any).logicalXDPI) 
- || 1, 1);
+ dpr = Math.max(
+ window.devicePixelRatio
+ || (window.screen && (window.screen as any).deviceXDPI / (window.screen as any).logicalXDPI)
+ || 1, 1
+ );
 }
 
 /**

src/core/PathProxy.ts

@@ -1059,8 +1059,8 @@ export default class PathProxy {
  const psi = d[i++];
  const anticlockwise = !d[i++];
  const r = (rx > ry) ? rx : ry;
- const scaleX = (rx > ry) ? 1 : rx / ry;
- const scaleY = (rx > ry) ? ry / rx : 1;
+ // const scaleX = (rx > ry) ? 1 : rx / ry;
+ // const scaleY = (rx > ry) ? ry / rx : 1;
  const isEllipse = mathAbs(rx - ry) > 1e-3;
  let endAngle = startAngle + delta;
  let breakBuild = false;
@@ -1174,6 +1174,7 @@ export interface PathRebuilder {
  bezierCurveTo(x: number, y: number, x2: number, y2: number, x3: number, y3: number): void
  quadraticCurveTo(x: number, y: number, x2: number, y2: number): void
  arc(cx: number, cy: number, r: number, startAngle: number, endAngle: number, anticlockwise: boolean): void
+ // eslint-disable-next-line max-len
  ellipse(cx: number, cy: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, anticlockwise: boolean): void
  rect(x: number, y: number, width: number, height: number): void
  closePath(): void

src/core/arrayDiff.ts

@@ -185,6 +185,6 @@ function clonePath(path: DiffPath) {
  return { newPos: path.newPos, components: path.components.slice(0) };
 }
 
-export default function arrayDiff<T> (oldArr: T[], newArr: T[], equal?: EqualFunc<T>): DiffComponent[] {
+export default function arrayDiff<T>(oldArr: T[], newArr: T[], equal?: EqualFunc<T>): DiffComponent[] {
  return diff(oldArr, newArr, equal);
 }

src/core/env.ts

@@ -74,7 +74,7 @@ function detect(ua: string, env: Env) {
  if (edge) {
  browser.edge = true;
  browser.version = edge[1];
- browser.newEdge = +edge[1].split('.')[0] > 18; 
+ browser.newEdge = +edge[1].split('.')[0] > 18;
  }
 
  // It is difficult to detect WeChat in Win Phone precisely, because ua can
@@ -108,7 +108,7 @@ function detect(ua: string, env: Env) {
 
  // except IE 6-8 and very old firefox 2-3 & opera 10.1
  // other browsers all support `transform`
- env.transformSupported = env.transform3dSupported 
+ env.transformSupported = env.transform3dSupported
  // transform 2D is supported in IE9
  || (browser.ie && +browser.version >= 9);
 

src/debug/showDebugDirtyRect.ts

@@ -17,7 +17,7 @@ class DebugRect {
  extend(style, {
  backgroundColor: 'rgba(0, 0, 255, 0.2)',
  border: '1px solid #00f'
- })
+ });
  dom.style.cssText = `
 position: absolute;
 opacity: 0;

src/graphic/Displayable.ts

@@ -79,6 +79,7 @@ export type DisplayableState = Pick<DisplayableProps, DisplayableStatePropNames>
 const PRIMARY_STATES_KEYS = ['z', 'z2', 'invisible'] as const;
 const PRIMARY_STATES_KEYS_IN_HOVER_LAYER = ['invisible'] as const;
 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 interface Displayable<Props extends DisplayableProps = DisplayableProps> {
  animate(key?: '', loop?: boolean): Animator<this>
  animate(key: 'style', loop?: boolean): Animator<this['style']>

src/graphic/Path.ts

@@ -107,6 +107,7 @@ export interface PathProps extends DisplayableProps {
 type PathKey = keyof PathProps
 type PathPropertyType = PropType<PathProps, PathKey>
 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 interface Path<Props extends PathProps = PathProps> {
  animate(key?: '', loop?: boolean): Animator<this>
  animate(key: 'style', loop?: boolean): Animator<this['style']>

src/graphic/helper/dashStyle.ts

@@ -5,9 +5,9 @@ export function normalizeLineDash(lineType: any, lineWidth?: number): number[] |
  return null;
  }
  lineWidth = lineWidth || 1;
- return lineType === 'dashed' 
+ return lineType === 'dashed'
  ? [4 * lineWidth, 2 * lineWidth]
- : lineType === 'dotted' 
+ : lineType === 'dotted'
  ? [lineWidth]
  : isNumber(lineType)
  ? [lineType] : isArray(lineType) ? lineType : null;

src/graphic/helper/roundSector.ts

@@ -22,9 +22,9 @@ type CornerTangents = {
 };
 
 function intersect(
- x0: number, y0: number, 
- x1: number, y1: number, 
- x2: number, y2: number, 
+ x0: number, y0: number,
+ x1: number, y1: number,
+ x2: number, y2: number,
  x3: number, y3: number
 ): [number, number] {
  const x10 = x1 - x0;
@@ -41,9 +41,9 @@ function intersect(
 
 // Compute perpendicular offset line of length rc.
 function computeCornerTangents(
- x0: number, y0: number, 
- x1: number, y1: number, 
- radius: number, cr: number, 
+ x0: number, y0: number,
+ x1: number, y1: number,
+ radius: number, cr: number,
  clockwise: boolean
 ): CornerTangents {
  const x01 = x0 - x1;
@@ -150,14 +150,14 @@ export function buildPath(ctx: CanvasRenderingContext2D | PathProxy, shape: {
  // is a circle or annulus
  else if (arc > PI2 - e) {
  ctx.moveTo(
- x + radius * mathCos(startAngle), 
+ x + radius * mathCos(startAngle),
  y + radius * mathSin(startAngle)
  );
  ctx.arc(x, y, radius, startAngle, endAngle, !clockwise);
 
  if (innerRadius > e) {
  ctx.moveTo(
- x + innerRadius * mathCos(endAngle), 
+ x + innerRadius * mathCos(endAngle),
  y + innerRadius * mathSin(endAngle)
  );
  ctx.arc(x, y, innerRadius, endAngle, startAngle, clockwise);
@@ -219,15 +219,17 @@ export function buildPath(ctx: CanvasRenderingContext2D | PathProxy, shape: {
 
  // Have the corners merged?
  if (cr1 < cr) {
+ // eslint-disable-next-line max-len
  ctx.arc(x + ct0.cx, y + ct0.cy, cr1, mathATan2(ct0.y01, ct0.x01), mathATan2(ct1.y01, ct1.x01), !clockwise);
  }
  else {
- // draw the two corners and the ring
- ctx.arc(x + ct0.cx, y + ct0.cy, cr1, mathATan2(ct0.y01, ct0.x01), mathATan2(ct0.y11, ct0.x11), !clockwise);
-
- ctx.arc(x, y, radius, mathATan2(ct0.cy + ct0.y11, ct0.cx + ct0.x11), mathATan2(ct1.cy + ct1.y11, ct1.cx + ct1.x11), !clockwise);
-
- ctx.arc(x + ct1.cx, y + ct1.cy, cr1, mathATan2(ct1.y11, ct1.x11), mathATan2(ct1.y01, ct1.x01), !clockwise);
+ // draw the two corners and the ring
+ // eslint-disable-next-line max-len
+ ctx.arc(x + ct0.cx, y + ct0.cy, cr1, mathATan2(ct0.y01, ct0.x01), mathATan2(ct0.y11, ct0.x11), !clockwise);
+ // eslint-disable-next-line max-len
+ ctx.arc(x, y, radius, mathATan2(ct0.cy + ct0.y11, ct0.cx + ct0.x11), mathATan2(ct1.cy + ct1.y11, ct1.cx + ct1.x11), !clockwise);
+ // eslint-disable-next-line max-len
+ ctx.arc(x + ct1.cx, y + ct1.cy, cr1, mathATan2(ct1.y11, ct1.x11), mathATan2(ct1.y01, ct1.x01), !clockwise);
  }
  }
  // the outer ring is a circular arc
@@ -248,15 +250,17 @@ export function buildPath(ctx: CanvasRenderingContext2D | PathProxy, shape: {
 
  // Have the corners merged?
  if (cr0 < icr) {
+ // eslint-disable-next-line max-len
  ctx.arc(x + ct0.cx, y + ct0.cy, cr0, mathATan2(ct0.y01, ct0.x01), mathATan2(ct1.y01, ct1.x01), !clockwise);
  }
  // draw the two corners and the ring
  else {
- ctx.arc(x + ct0.cx, y + ct0.cy, cr0, mathATan2(ct0.y01, ct0.x01), mathATan2(ct0.y11, ct0.x11), !clockwise);
-
- ctx.arc(x, y, innerRadius, mathATan2(ct0.cy + ct0.y11, ct0.cx + ct0.x11), mathATan2(ct1.cy + ct1.y11, ct1.cx + ct1.x11), clockwise);
-
- ctx.arc(x + ct1.cx, y + ct1.cy, cr0, mathATan2(ct1.y11, ct1.x11), mathATan2(ct1.y01, ct1.x01), !clockwise);
+ // eslint-disable-next-line max-len
+ ctx.arc(x + ct0.cx, y + ct0.cy, cr0, mathATan2(ct0.y01, ct0.x01), mathATan2(ct0.y11, ct0.x11), !clockwise);
+ // eslint-disable-next-line max-len
+ ctx.arc(x, y, innerRadius, mathATan2(ct0.cy + ct0.y11, ct0.cx + ct0.x11), mathATan2(ct1.cy + ct1.y11, ct1.cx + ct1.x11), clockwise);
+ // eslint-disable-next-line max-len
+ ctx.arc(x + ct1.cx, y + ct1.cy, cr0, mathATan2(ct1.y11, ct1.x11), mathATan2(ct1.y01, ct1.x01), !clockwise);
  }
  }
  // the inner ring is just a circular arc

src/graphic/shape/Sector.ts

@@ -30,7 +30,7 @@ class Sector extends Path<SectorProps> {
  }
 
  buildPath(ctx: CanvasRenderingContext2D, shape: SectorShape) {
- roundSectorHelper.buildPath(ctx, shape)
+ roundSectorHelper.buildPath(ctx, shape);
  }
 
  isZeroArea() {

src/svg/Painter.ts

@@ -444,13 +444,11 @@ class SVGPainter implements PainterBase {
  dispose() {
  this.root.innerHTML = '';
 
- this._svgRoot
- = this._backgroundRoot
- = this._svgDom
- = this._backgroundNode
- = this._viewport
- = this.storage
- = null;
+ this._svgRoot =
+ this._backgroundRoot =
+ this._svgDom =
+ this._backgroundNode =
+ this._viewport = this.storage = null;
  }
 
  clear() {

src/tool/dividePath.ts

@@ -1,7 +1,7 @@
 import { fromPoints } from '../core/bbox';
 import BoundingRect from '../core/BoundingRect';
 import Point from '../core/Point';
-import { each, map } from '../core/util';
+import { map } from '../core/util';
 import Path from '../graphic/Path';
 import Polygon from '../graphic/shape/Polygon';
 import Rect from '../graphic/shape/Rect';

src/tool/morphPath.ts

@@ -2,7 +2,7 @@ import PathProxy from '../core/PathProxy';
 import { cubicSubdivide } from '../core/curve';
 import Path from '../graphic/Path';
 import Element, { ElementAnimateConfig } from '../Element';
-import { defaults, extend, map } from '../core/util';
+import { defaults, map } from '../core/util';
 import { lerp } from '../core/vector';
 import Group, { GroupLike } from '../graphic/Group';
 import { clonePath } from './path';
@@ -558,10 +558,15 @@ function hilbert(x: number, y: number, minX: number, minY: number, maxX: number,
  let d = 0;
  let tmp: number;
  for (let s = (1 << bits) / 2; s > 0; s /= 2) {
- let rx = 0, ry = 0;
+ let rx = 0;
+ let ry = 0;
 
- if ((x & s) > 0) rx = 1;
- if ((y & s) > 0) ry = 1;
+ if ((x & s) > 0) {
+ rx = 1;
+ }
+ if ((y & s) > 0) {
+ ry = 1;
+ }
 
  d += s * s * ((3 * rx) ^ ry);
 
@@ -603,7 +608,7 @@ function sortPaths(pathList: Path[]): Path[] {
  cp,
  z: hilbert(cp[0], cp[1], xMin, yMin, xMax, yMax),
  path: pathList[idx]
- }
+ };
  });
 
  return items.sort((a, b) => a.z - b.z).map(item => item.path);
@@ -645,7 +650,7 @@ function createEmptyReturn() {
  fromIndividuals: [] as Path[],
  toIndividuals: [] as Path[],
  count: 0
- }
+ };
 }
 /**
  * Make combine morphing from many paths to one.
@@ -756,7 +761,7 @@ export function combineMorph(
  restoreToPath();
  oldDone && oldDone();
  }
- }
+ };
  // Animate each element individually.
  for (let i = 0; i < toLen; i++) {
  // TODO only call during once?
@@ -886,4 +891,4 @@ export function separateMorph(
  };
 }
 
-export { split as defaultDividePath }
+export { split as defaultDividePath };

src/vml/Painter.ts

@@ -3,9 +3,8 @@
  * VML Painter.
  */
 
-import {logError} from '../core/util';
+import {logError, each} from '../core/util';
 import * as vmlCore from './core';
-import {each} from '../core/util';
 
 function parseInt10(val) {
  return parseInt(val, 10);

src/zrender.ts

@@ -15,7 +15,7 @@ import Storage from './Storage';
 import {PainterBase} from './PainterBase';
 import Animation from './animation/Animation';
 import HandlerProxy from './dom/HandlerProxy';
-import Element, {ElementEventCallback, ElementEvent} from './Element';
+import Element, { ElementEventCallback } from './Element';
 import { Dictionary, ElementEventName, RenderedEvent, WithThisType } from './core/types';
 import { LayerConfig } from './canvas/Layer';
 import { GradientObject } from './graphic/Gradient';
@@ -407,6 +407,7 @@ class ZRender {
  }
 
  on<Ctx>(eventName: ElementEventName, eventHandler: ElementEventCallback<Ctx, ZRenderType>, context?: Ctx): this
+ // eslint-disable-next-line max-len
  on<Ctx>(eventName: string, eventHandler: WithThisType<EventCallback<any[]>, unknown extends Ctx ? ZRenderType : Ctx>, context?: Ctx): this
  // eslint-disable-next-line max-len
  on<Ctx>(eventName: string, eventHandler: (...args: any) => any, context?: Ctx): this {