9478568050

Committed 12 Jun 2024 07:33AM UTC coverage: 56.968% (-2.6%) from 59.55%

Build # 9478568050

Build Type

push

github

Committed by

web-flow

Commit Message

chore: type mis (#356)

* chore: type mis

* chore: compiler options target

Run Details

960 of 2222 branches covered (43.2%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 1 file covered. (100.0%)

916 existing lines in 53 files now uncovered.

2768 of 4322 relevant lines covered (64.04%)

234.63 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

61.11

/packages/l7plot/src/core/plot/index.ts

import { Source } from '@antv/l7';
import { Map } from '../map';
import { deepAssign } from '../../utils';
import { TextLayer } from '../../layers/text-layer';
import { PlotType } from '../../types';
import type { PlotOptions, LabelOptions, SourceOptions, Scene, PlotLayerOptions } from '../../types';
import { LayerGroup } from '../layer/layer-group';
import { MappingSource } from '../../adaptor/source';
import { isEqual } from '@antv/util';
import { getTheme } from '../../theme';

const DEFAULT_OPTIONS: Partial<PlotOptions> = {
  autoFit: false,
};

export abstract class Plot<O extends PlotOptions> extends Map<O> {
  /**
   * 默认的 options 配置项
   */
  static DefaultOptions = DEFAULT_OPTIONS;
  /**
   * 地图图表类型
   */
  static PlotType = PlotType;
  /**
   * 图表类型名称
   */
  public abstract readonly type: PlotType | string;
  /**
   * 数据
   */
  public source!: Source;

  constructor(container: O);
  constructor(container: string | HTMLDivElement, options: O);
  constructor(container: string | HTMLDivElement | O, options?: O) {
    if (typeof container === 'string' || container instanceof Element) {
      if (options === undefined) {
        throw new Error('options is undefined');
      }
      super(options);
      this.container = this.createContainer(container);

      this.theme = this.createTheme();
      this.scene = this.createScene();

      this.registerResources();
      this.initSource();
    } else {
      super(container);
    }
  }

  /**
   * 初始化数据
   */
  protected initSource() {
    this.source = this.createSource();
    this.render();
    this.inited = true;
  }

  /**
   * 初始化图层事件
   */
  protected initLayersEvent() {
    //
  }

  /**
   * 获取默认配置
   */
  protected getDefaultOptions(): Partial<PlotOptions> {
    return Plot.DefaultOptions;
  }

  /**
   * 创建 source 实例
   */
  protected createSource() {
    const { data, aggregation, ...sourceCFG } = this.options.source;
    aggregation && MappingSource.aggregation(sourceCFG, aggregation);
    const source = new Source(data, sourceCFG);
    return source;
  }

  /**
   * 创建图层
   */
  protected abstract createLayers(source: Source): LayerGroup;

  /**
   * 更新图层
   */
  protected abstract updateLayers(options: Partial<O>): void;

  /**
   * 创建数据标签图层
   */
  protected createLabelLayer(source: Source, label: LabelOptions, plotLayerConfig?: PlotLayerOptions): TextLayer {
    const { visible, minZoom, maxZoom, zIndex = 0 } = plotLayerConfig || {};
    const textLayer = new TextLayer({
      name: 'labelLayer',
      visible,
      minZoom,
      maxZoom,
      zIndex: zIndex + 0.1,
      source,
      ...label,
    });
    return textLayer;
  }

  /**
   * 更新数据标签图层
   */
  protected updateLabelLayer(
    source: Source,
    label?: false | LabelOptions,
    plotLayerConfig?: PlotLayerOptions,
    labelLayer?: TextLayer,
  ) {
    if (label) {
      if (labelLayer) {
        labelLayer.update({ ...label });
      } else {
        labelLayer = this.createLabelLayer(source, label, plotLayerConfig);
        this.layerGroup.addLayer(labelLayer);
      }
    } else if (label === false) {
      labelLayer && this.layerGroup.removeLayer(labelLayer);
    }
  }

  /**
   * 渲染
   */
  public render() {
    const layerGroup = this.createLayers(this.source);
    if (this.inited) {
      this.layerGroup.removeAllLayer();
      layerGroup.addTo(this.scene);
      this.layerGroup = layerGroup;
      // this.scene.render();
    } else {
      this.layerGroup = layerGroup;
      if (this.scene['sceneService'].loaded) {
        this.onSceneLoaded();
      } else {
        this.scene.once('loaded', () => {
          this.onSceneLoaded();
        });
      }
    }
    this.initLayersEvent();
  }

  /**
   * scene 加载成功回调
   */
  protected onSceneLoaded() {
    this.sceneLoaded = true;

    if (this.layerGroup.isEmpty()) {
      this.onLayersLoaded();
    } else {
      this.layerGroup.once('inited-all', () => {
        this.onLayersLoaded();
      });
    }

    this.layerGroup.addTo(this.scene);
  }

  /**
   * 图层加载成功回调
   */
  protected onLayersLoaded() {
    this.layersLoaded = true;
    this.initComponents();
    this.loaded = true;
    this.emit('loaded');
  }

  /**
   * 挂载到容器
   * 用于高级图表 L7Plot 挂载单个图表示例
   */
  public attachToScene(scene: Scene, theme?: Record<string, any>) {
    this.scene = scene;
    this.theme = theme ? theme : getTheme('default');
    this.registerResources();
    this.initSource();
  }

  /**
   * 取消挂载到容器上的 scene
   * 用于高级图表 L7Plot 挂载单个图表示例
   */
  public unattachFromScene() {
    this.removeAllLayer();
    this.tooltip?.destroy();
  }

  /**
   * 添加到容器
   * 用于 L7 Scene 与图表混合使用场景
   */
  public addToScene(scene: Scene) {
    this.attachToScene(scene);
  }

  /**
   * 从容器上移除
   * 用于 L7 Scene 与图表混合使用场景
   */
  public removeFromScene() {
    this.removeAllLayer();
    this.removeScaleControl();
    this.removeZoomControl();
    this.removeLayerMenuControl();
    this.removeLegendControl();
    this.tooltip?.destroy();
  }

  /**
   * 更新: 更新配置且重新渲染
   */
  public update(options: Partial<O>) {
    this.updateOption(options);
    if (options.map && !isEqual(this.lastOptions.map, this.options.map)) {
      this.updateMap(options.map);
    }
    this.scene.setEnableRender(false);
    if (options.source && !isEqual(this.lastOptions.source, this.options.source)) {
      const { data, ...sourceConfig } = options.source;
      this.changeData(data, sourceConfig);
    }
    // this.updateLayers(options);
    this.scene.setEnableRender(true);
    this.render();
    this.updateComponents();
    this.emit('update');
  }

  /**
   * 更新: 更新数据
   */
  public changeData(data: any, cfg?: Omit<SourceOptions, 'data'>) {
    this.options.source = deepAssign({}, this.options.source, { data, ...cfg });
    const { aggregation, ...sourceCFG } = this.options.source;
    aggregation && MappingSource.aggregation(sourceCFG, aggregation);

    this.source.setData(this.options.source.data, sourceCFG);

    // 更新 legend
    // TODO: 数据更新后，图层尚未执行更新，后续加图层 update 事件来解决
    const legend = this.options.legend;
    if (legend) {
      setTimeout(() => {
        this.updateLegendControl(legend);
      }, 500);
    }

    this.emit('change-data');
  }
}

1	import { Source } from '@antv/l7';
2	import { Map } from '../map';	124✔
3	import { deepAssign } from '../../utils';	124✔
4	import { TextLayer } from '../../layers/text-layer';	124✔
5	import { PlotType } from '../../types';	124✔
6	import type { PlotOptions, LabelOptions, SourceOptions, Scene, PlotLayerOptions } from '../../types';	124✔
7	import { LayerGroup } from '../layer/layer-group';	124✔
8	import { MappingSource } from '../../adaptor/source';	124✔
9	import { isEqual } from '@antv/util';	124✔
10	import { getTheme } from '../../theme';	124✔
11		124✔
12	const DEFAULT_OPTIONS: Partial<PlotOptions> = {	124✔
13	autoFit: false,	124✔
14	};
15
16	export abstract class Plot<O extends PlotOptions> extends Map<O> {
17	/**
18	* 默认的 options 配置项	334!
19	*/	334!
UNCOV 20	static DefaultOptions = DEFAULT_OPTIONS;	×
21	/**
22	* 地图图表类型	334✔
23	*/	334✔
24	static PlotType = PlotType;	334✔
25	/**	334✔
26	* 图表类型名称	334✔
27	*/	334✔
28	public abstract readonly type: PlotType \| string;
29	/**
UNCOV 30	* 数据	×
31	*/
32	public source!: Source;
33
34	constructor(container: O);
35	constructor(container: string \| HTMLDivElement, options: O);
36	constructor(container: string \| HTMLDivElement \| O, options?: O) {
37	if (typeof container === 'string' \|\| container instanceof Element) {	334✔
38	if (options === undefined) {	334✔
39	throw new Error('options is undefined');	334✔
40	}
41	super(options);
42	this.container = this.createContainer(container);
43
44	this.theme = this.createTheme();
45	this.scene = this.createScene();
46
47	this.registerResources();
48	this.initSource();
49	} else {
50	super(container);
51	}	3✔
52	}
53
54	/**
55	* 初始化数据
56	*/
57	protected initSource() {	334✔
58	this.source = this.createSource();	334✔
59	this.render();	334✔
60	this.inited = true;	334✔
61	}
62
63	/**
64	* 初始化图层事件
65	*/
66	protected initLayersEvent() {	20!
67	//	20✔
68	}
69
70	/**	20✔
71	* 获取默认配置
72	*/
73	protected getDefaultOptions(): Partial<PlotOptions> {
74	return Plot.DefaultOptions;
75	}
UNCOV 76		×
77	/**	×
78	* 创建 source 实例	×
79	*/
80	protected createSource() {
UNCOV 81	const { data, aggregation, ...sourceCFG } = this.options.source;	×
82	aggregation && MappingSource.aggregation(sourceCFG, aggregation);	×
83	const source = new Source(data, sourceCFG);
84	return source;
UNCOV 85	}	×
86		×
87	/**
88	* 创建图层
89	*/
90	protected abstract createLayers(source: Source): LayerGroup;
91
92	/**
93	* 更新图层	366✔
94	*/	366✔
95	protected abstract updateLayers(options: Partial<O>): void;	32✔
96		32✔
97	/**	32✔
98	* 创建数据标签图层
99	*/
100	protected createLabelLayer(source: Source, label: LabelOptions, plotLayerConfig?: PlotLayerOptions): TextLayer {
101	const { visible, minZoom, maxZoom, zIndex = 0 } = plotLayerConfig \|\| {};	334✔
102	const textLayer = new TextLayer({	334!
UNCOV 103	name: 'labelLayer',	×
104	visible,
105	minZoom,
106	maxZoom,	334✔
107	zIndex: zIndex + 0.1,	334✔
108	source,
109	...label,
110	});
111	return textLayer;	366✔
112	}
113
114	/**
115	* 更新数据标签图层
116	*/
117	protected updateLabelLayer(	334✔
118	source: Source,	334✔
119	label?: false \| LabelOptions,	3✔
120	plotLayerConfig?: PlotLayerOptions,
121	labelLayer?: TextLayer,
122	) {	331✔
123	if (label) {	330✔
124	if (labelLayer) {
125	labelLayer.update({ ...label });
126	} else {	334✔
127	labelLayer = this.createLabelLayer(source, label, plotLayerConfig);
128	this.layerGroup.addLayer(labelLayer);
129	}
130	} else if (label === false) {
131	labelLayer && this.layerGroup.removeLayer(labelLayer);
132	}	333✔
133	}	333✔
134		333✔
135	/**	333✔
136	* 渲染
137	*/
138	public render() {
139	const layerGroup = this.createLayers(this.source);
140	if (this.inited) {
141	this.layerGroup.removeAllLayer();
UNCOV 142	layerGroup.addTo(this.scene);	×
UNCOV 143	this.layerGroup = layerGroup;	×
UNCOV 144	// this.scene.render();	×
145	} else {	×
146	this.layerGroup = layerGroup;
147	if (this.scene['sceneService'].loaded) {
148	this.onSceneLoaded();
149	} else {
150	this.scene.once('loaded', () => {
151	this.onSceneLoaded();
152	});
UNCOV 153	}	×
UNCOV 154	}	×
155	this.initLayersEvent();
156	}
157
158	/**
159	* scene 加载成功回调
160	*/
UNCOV 161	protected onSceneLoaded() {	×
162	this.sceneLoaded = true;
163
164	if (this.layerGroup.isEmpty()) {
165	this.onLayersLoaded();
166	} else {
167	this.layerGroup.once('inited-all', () => {
168	this.onLayersLoaded();
UNCOV 169	});	×
UNCOV 170	}	×
UNCOV 171		×
172	this.layerGroup.addTo(this.scene);	×
173	}	×
174		×
175	/**
176	* 图层加载成功回调
177	*/
178	protected onLayersLoaded() {
179	this.layersLoaded = true;
180	this.initComponents();	16✔
181	this.loaded = true;	16!
UNCOV 182	this.emit('loaded');	×
183	}
184		16✔
185	/**	16!
UNCOV 186	* 挂载到容器	×
UNCOV 187	* 用于高级图表 L7Plot 挂载单个图表示例	×
188	*/
189	public attachToScene(scene: Scene, theme?: Record<string, any>) {
190	this.scene = scene;	16✔
191	this.theme = theme ? theme : getTheme('default');	16✔
192	this.registerResources();	16✔
193	this.initSource();	16✔
194	}
195
196	/**
197	* 取消挂载到容器上的 scene
198	* 用于高级图表 L7Plot 挂载单个图表示例
199	*/	16✔
200	public unattachFromScene() {	16✔
201	this.removeAllLayer();	16!
202	this.tooltip?.destroy();	16✔
203	}
204
205	/**	16✔
206	* 添加到容器	16!
UNCOV 207	* 用于 L7 Scene 与图表混合使用场景	×
UNCOV 208	*/	×
209	public addToScene(scene: Scene) {
210	this.attachToScene(scene);
211	}	16✔
212
213	/**
214	* 从容器上移除	124✔
215	* 用于 L7 Scene 与图表混合使用场景
216	*/
217	public removeFromScene() {
218	this.removeAllLayer();	124✔
219	this.removeScaleControl();
220	this.removeZoomControl();
221	this.removeLayerMenuControl();
222	this.removeLegendControl();	124✔
223	this.tooltip?.destroy();
224	}
225
226	/**
227	* 更新: 更新配置且重新渲染
228	*/
229	public update(options: Partial<O>) {
230	this.updateOption(options);
231	if (options.map && !isEqual(this.lastOptions.map, this.options.map)) {
232	this.updateMap(options.map);
233	}
234	this.scene.setEnableRender(false);
235	if (options.source && !isEqual(this.lastOptions.source, this.options.source)) {
236	const { data, ...sourceConfig } = options.source;
237	this.changeData(data, sourceConfig);
238	}
239	// this.updateLayers(options);
240	this.scene.setEnableRender(true);
241	this.render();
242	this.updateComponents();
243	this.emit('update');
244	}
245
246	/**
247	* 更新: 更新数据
248	*/
249	public changeData(data: any, cfg?: Omit<SourceOptions, 'data'>) {
250	this.options.source = deepAssign({}, this.options.source, { data, ...cfg });
251	const { aggregation, ...sourceCFG } = this.options.source;
252	aggregation && MappingSource.aggregation(sourceCFG, aggregation);
253
254	this.source.setData(this.options.source.data, sourceCFG);
255
256	// 更新 legend
257	// TODO: 数据更新后，图层尚未执行更新，后续加图层 update 事件来解决
258	const legend = this.options.legend;
259	if (legend) {
260	setTimeout(() => {
261	this.updateLegendControl(legend);
262	}, 500);
263	}
264
265	this.emit('change-data');
266	}
267	}

antvis / L7Plot / 9478568050

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous