add axis model creator type

src/component/gridSimple.ts

@@ -24,6 +24,7 @@ import * as zrUtil from 'zrender/src/core/util';
 import * as graphic from '../util/graphic';
 
 import '../coord/cartesian/Grid';
+import '../coord/cartesian/GridModel';
 import './axis';
 
 // Grid view

src/component/legend.ts

@@ -26,12 +26,12 @@ import './legend/legendAction';
 import './legend/LegendView';
 
 import legendFilter from './legend/legendFilter';
-import Component, { ComponentModelConstructor } from '../model/Component';
+import Component from '../model/Component';
 
 // Series Filter
 echarts.registerProcessor(echarts.PRIORITY.PROCESSOR.SERIES_FILTER, legendFilter);
 
-(Component as ComponentModelConstructor).registerSubTypeDefaulter('legend', function () {
+Component.registerSubTypeDefaulter('legend', function () {
     // Default 'plain' when no type specified.
     return 'plain';
 });

src/component/tooltip/TooltipHTMLContent.ts

@@ -28,6 +28,8 @@ import { ZRenderType } from 'zrender/src/zrender';
 import { TooltipOption } from './TooltipModel';
 import Model from '../../model/Model';
 import { ZRRawEvent } from 'zrender/src/core/types';
+import CanvasPainter from 'zrender/src/canvas/Painter';
+import SVGPainter from 'zrender/src/svg/Painter';
 
 var each = zrUtil.each;
 var toCamelCase = formatUtil.toCamelCase;
@@ -134,7 +136,7 @@ function makeStyleCoord(out: number[], zr: ZRenderType, appendToBody: boolean, z
         // xy should be based on canvas root. But tooltipContent is
         // the sibling of canvas root. So padding of ec container
         // should be considered here.
-        var viewportRootOffset = zrPainter && zrPainter.getViewportRootOffset();
+        var viewportRootOffset = zrPainter && (zrPainter as CanvasPainter | SVGPainter).getViewportRootOffset();
         if (viewportRootOffset) {
             out[0] += viewportRootOffset.offsetLeft;
             out[1] += viewportRootOffset.offsetTop;

src/component/visualMap/typeDefaulter.ts

@@ -17,12 +17,12 @@
 * under the License.
 */
 
-import Component, { ComponentModelConstructor } from '../../model/Component';
+import Component from '../../model/Component';
 import {VisualMapOption} from './VisualMapModel';
 import {PiecewiseVisualMapOption} from './PiecewiseModel';
 import {ContinousVisualMapOption} from './ContinuousModel';
 
-(Component as ComponentModelConstructor).registerSubTypeDefaulter(
+Component.registerSubTypeDefaulter(
     'visualMap', function (option: VisualMapOption) {
     // Compatible with ec2, when splitNumber === 0, continuous visualMap will be used.
     return (

src/coord/CoordinateSystem.ts

@@ -52,7 +52,7 @@ export interface CoordinateSystemMaster {
 
     model?: Model;
 
-    update(ecModel: GlobalModel, api: ExtensionAPI): void;
+    update?: (ecModel: GlobalModel, api: ExtensionAPI) => void;
 
     // This methods is also responsible for determine whether this
     // coodinate system is applicable to the given `finder`.

src/coord/axisCommonTypes.ts

@@ -24,7 +24,9 @@ import {
 import { Dictionary } from 'zrender/src/core/types';
 
 
-export type OptionAxisType = 'category' | 'value' | 'time' | 'log';
+export var AXIS_TYPES = {value: 1, category: 1, time: 1, log: 1} as const;
+export type OptionAxisType = keyof typeof AXIS_TYPES;
+
 
 export interface AxisBaseOption extends ComponentOption {
     type?: OptionAxisType;

src/coord/axisDefault.ts

@@ -174,8 +174,8 @@ var logAxis: AxisBaseOption = zrUtil.defaults({
 
 
 export default {
-    categoryAxis: categoryAxis,
-    valueAxis: valueAxis,
-    timeAxis: timeAxis,
-    logAxis: logAxis
+    category: categoryAxis,
+    value: valueAxis,
+    time: timeAxis,
+    log: logAxis
 };

src/coord/axisModelCreator.ts

@@ -17,8 +17,6 @@
 * under the License.
 */
 
-// @ts-nocheck
-
 import * as zrUtil from 'zrender/src/core/util';
 import axisDefault from './axisDefault';
 import ComponentModel from '../model/Component';
@@ -28,95 +26,100 @@ import {
     fetchLayoutMode
 } from '../util/layout';
 import OrdinalMeta from '../data/OrdinalMeta';
-import { DimensionName, ComponentOption } from '../util/types';
-import { OptionAxisType } from './axisCommonTypes';
+import { DimensionName, BoxLayoutOptionMixin, OrdinalRawValue } from '../util/types';
+import { AxisBaseOption, AXIS_TYPES } from './axisCommonTypes';
+import GlobalModel from '../model/Global';
 
 
-// FIXME axisType is fixed ?
-var AXIS_TYPES = ['value', 'category', 'time', 'log'];
+type Constructor<T> = new (...args: any[]) => T;
 
 /**
  * Generate sub axis model class
- * @param axisName 'x' 'y' 'radius' 'angle' 'parallel'
- * @param {module:echarts/model/Component} BaseAxisModelClass
- * @param {Function} axisTypeDefaulter
- * @param {Object} [extraDefaultOption]
+ * @param axisName 'x' 'y' 'radius' 'angle' 'parallel' ...
  */
-export default function (
+export default function <
+    AxisOptionT extends AxisBaseOption,
+    AxisModelCtor extends Constructor<ComponentModel<AxisOptionT>>
+>(
     axisName: DimensionName,
-    BaseAxisModelClass,
-    axisTypeDefaulter: (axisDim: DimensionName, option: ComponentOption) => OptionAxisType,
-    extraDefaultOption?: ComponentOption
+    BaseAxisModelClass: AxisModelCtor,
+    extraDefaultOption?: AxisOptionT
 ) {
 
-    zrUtil.each(AXIS_TYPES, function (axisType) {
+    zrUtil.each(AXIS_TYPES, function (v, axisType) {
 
-        BaseAxisModelClass.extend({
+        var defaultOption = zrUtil.merge(
+            zrUtil.merge({}, axisDefault[axisType], true),
+            extraDefaultOption, true
+        );
 
-            /**
-             * @readOnly
-             */
-            type: axisName + 'Axis.' + axisType,
+        class AxisModel extends BaseAxisModelClass {
+
+            static type = axisName + 'Axis.' + axisType;
+            type = axisName + 'Axis.' + axisType;
+
+            static defaultOption = defaultOption;
+
+            private __ordinalMeta: OrdinalMeta;
 
-            mergeDefaultAndTheme: function (option, ecModel) {
+            constructor(...args: any[]) {
+                super(...args);
+            }
+
+            mergeDefaultAndTheme(option: AxisOptionT, ecModel: GlobalModel): void {
                 var layoutMode = fetchLayoutMode(this);
                 var inputPositionParams = layoutMode
-                    ? getLayoutParams(option) : {};
+                    ? getLayoutParams(option as BoxLayoutOptionMixin) : {};
 
                 var themeModel = ecModel.getTheme();
                 zrUtil.merge(option, themeModel.get(axisType + 'Axis'));
                 zrUtil.merge(option, this.getDefaultOption());
 
-                option.type = axisTypeDefaulter(axisName, option);
+                option.type = getAxisType(option);
 
                 if (layoutMode) {
-                    mergeLayoutParam(option, inputPositionParams, layoutMode);
+                    mergeLayoutParam(option as BoxLayoutOptionMixin, inputPositionParams, layoutMode);
                 }
-            },
+            }
 
-            /**
-             * @override
-             */
-            optionUpdated: function () {
+            optionUpdated(): void {
                 var thisOption = this.option;
                 if (thisOption.type === 'category') {
                     this.__ordinalMeta = OrdinalMeta.createByAxisModel(this);
                 }
-            },
+            }
 
             /**
              * Should not be called before all of 'getInitailData' finished.
              * Because categories are collected during initializing data.
              */
-            getCategories: function (rawData) {
+            getCategories(rawData: boolean): OrdinalRawValue[] | AxisBaseOption['data'] {
                 var option = this.option;
                 // FIXME
                 // warning if called before all of 'getInitailData' finished.
                 if (option.type === 'category') {
                     if (rawData) {
-                        return option.data;
+                        return option.data as AxisBaseOption['data'];
                     }
                     return this.__ordinalMeta.categories;
                 }
-            },
+            }
 
-            getOrdinalMeta: function () {
+            getOrdinalMeta(): OrdinalMeta {
                 return this.__ordinalMeta;
-            },
-
-            defaultOption: zrUtil.mergeAll(
-                [
-                    {},
-                    axisDefault[axisType + 'Axis'],
-                    extraDefaultOption
-                ],
-                true
-            )
-        });
+            }
+        }
+
+        ComponentModel.registerClass(AxisModel);
     });
 
     ComponentModel.registerSubTypeDefaulter(
         axisName + 'Axis',
-        zrUtil.curry(axisTypeDefaulter, axisName)
+        getAxisType
     );
 }
+
+function getAxisType(option: AxisBaseOption) {
+    // Default axis with data is category axis
+    return option.type || (option.data ? 'category' : 'value');
+}

src/coord/cartesian/AxisModel.ts

@@ -22,7 +22,6 @@ import ComponentModel from '../../model/Component';
 import axisModelCreator from '../axisModelCreator';
 import {AxisModelCommonMixin} from '../axisModelCommonMixin';
 import Axis2D from './Axis2D';
-import { DimensionName } from '../../util/types';
 import { AxisBaseOption } from '../axisCommonTypes';
 import GridModel from './GridModel';
 
@@ -69,11 +68,6 @@ class AxisModel extends ComponentModel<CartesianAxisOption> {
 
 ComponentModel.registerClass(AxisModel);
 
-function getAxisType(axisDim: DimensionName, option: CartesianAxisOption) {
-    // Default axis with data is category axis
-    return option.type || (option.data ? 'category' : 'value');
-}
-
 interface AxisModel extends AxisModelCommonMixin<CartesianAxisOption> {}
 zrUtil.mixin(AxisModel, AxisModelCommonMixin);
 
@@ -83,7 +77,7 @@ var extraOption: CartesianAxisOption = {
     offset: 0
 };
 
-axisModelCreator('x', AxisModel, getAxisType, extraOption);
-axisModelCreator('y', AxisModel, getAxisType, extraOption);
+axisModelCreator<CartesianAxisOption, typeof AxisModel>('x', AxisModel, extraOption);
+axisModelCreator<CartesianAxisOption, typeof AxisModel>('y', AxisModel, extraOption);
 
 export default AxisModel;

src/coord/cartesian/GridModel.ts

@@ -37,7 +37,7 @@ interface GridOption extends ComponentOption, BoxLayoutOptionMixin, ShadowOption
     tooltop?: any; // FIXME:TS add this tooltip type
 }
 
-export default class extends ComponentModel<GridOption> implements CoordinateSystemHostModel {
+class GridModel extends ComponentModel<GridOption> implements CoordinateSystemHostModel {
 
     static type = 'grid';
 
@@ -63,5 +63,8 @@ export default class extends ComponentModel<GridOption> implements CoordinateSys
         borderWidth: 1,
         borderColor: '#ccc'
     }
+}
+
+ComponentModel.registerClass(GridModel);
 
-}
\ No newline at end of file
+export default GridModel;

src/coord/parallel/AxisModel.ts

@@ -142,10 +142,6 @@ var defaultOption = {
 
 zrUtil.mixin(AxisModel, AxisModelCommonMixin);
 
-function getAxisType(axisName, option) {
-    return option.type || (option.data ? 'category' : 'value');
-}
-
-axisModelCreator('parallel', AxisModel, getAxisType, defaultOption);
+axisModelCreator('parallel', AxisModel, defaultOption);
 
 export default AxisModel;
\ No newline at end of file

src/coord/polar/AxisModel.ts

@@ -71,10 +71,5 @@ var polarAxisDefaultExtendedOption = {
     }
 };
 
-function getAxisType(axisDim, option) {
-    // Default axis with data is category axis
-    return option.type || (option.data ? 'category' : 'value');
-}
-
-axisModelCreator('angle', PolarAxisModel, getAxisType, polarAxisDefaultExtendedOption.angle);
-axisModelCreator('radius', PolarAxisModel, getAxisType, polarAxisDefaultExtendedOption.radius);
+axisModelCreator('angle', PolarAxisModel, polarAxisDefaultExtendedOption.angle);
+axisModelCreator('radius', PolarAxisModel, polarAxisDefaultExtendedOption.radius);

src/coord/radar/RadarModel.ts

@@ -25,7 +25,7 @@ import axisDefault from '../axisDefault';
 import Model from '../../model/Model';
 import {AxisModelCommonMixin} from '../axisModelCommonMixin';
 
-var valueAxisDefault = axisDefault.valueAxis;
+var valueAxisDefault = axisDefault.value;
 
 function defaultsShow(opt, show) {
     return zrUtil.defaults({

src/coord/single/AxisModel.ts

@@ -99,12 +99,8 @@ var defaultOption = {
     }
 };
 
-function getAxisType(axisName, option) {
-    return option.type || (option.data ? 'category' : 'value');
-}
-
 zrUtil.mixin(AxisModel, {AxisModelCommonMixin});
 
-axisModelCreator('single', AxisModel, getAxisType, defaultOption);
+axisModelCreator('single', AxisModel, defaultOption);
 
 export default AxisModel;
\ No newline at end of file

src/helper.ts

@@ -76,13 +76,21 @@ export {createSymbol} from './util/symbol';
 /**
  * Create scale
  * @param {Array.<number>} dataExtent
- * @param {Object|module:echarts/Model} option
+ * @param {Object|module:echarts/Model} option If `optoin.type`
+ *        is secified, it can only be `'value'` currently.
  */
 export function createScale(dataExtent, option) {
     var axisModel = option;
     if (!Model.isInstance(option)) {
         axisModel = new Model(option);
-        zrUtil.mixin(axisModel, AxisModelCommonMixin);
+        // FIXME
+        // Currently AxisModelCommonMixin has nothing to do with the
+        // the requirements of `axisHelper.createScaleByModel`. For
+        // example the method `getCategories` and `getOrdinalMeta`
+        // are required for `'category'` axis, and ecModel are required
+        // for `'time'` axis. But occationally echarts-gl happened
+        // to only use `'value'` axis.
+        // zrUtil.mixin(axisModel, AxisModelCommonMixin);
     }
 
     var scale = axisHelper.createScaleByModel(axisModel);

src/model/Component.ts

@@ -286,6 +286,8 @@ class ComponentModel<Opt extends ComponentOption = ComponentOption> extends Mode
     }
 
     static registerClass: ClassManager['registerClass'];
+
+    static registerSubTypeDefaulter: componentUtil.SubTypeDefaulterManager['registerSubTypeDefaulter'];
 }
 
 // Reset ComponentModel.extend, add preConstruct.