8730869952

Committed 18 Apr 2024 01:10AM UTC coverage: 90.012% (+0.008%) from 90.004%

Build # 8730869952

Build Type

push

github

Committed by

web-flow

Commit Message

fix(geo-layers): TileLayer default autoHighlight (#8798)

Run Details

6299 of 6932 branches covered (90.87%)

Branch coverage included in aggregate %.

7 of 8 new or added lines in 1 file covered. (87.5%)

1 existing line in 1 file now uncovered.

51718 of 57523 relevant lines covered (89.91%)

6698.1 hits per line

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

99.13

/modules/geo-layers/src/tile-layer/tile-layer.ts

import {
  CompositeLayer,
  CompositeLayerProps,
  Layer,
  LayerProps,
  UpdateParameters,
  PickingInfo,
  GetPickingInfoParams,
  DefaultProps,
  FilterContext,
  _flatten as flatten
} from '@deck.gl/core';
import {GeoJsonLayer} from '@deck.gl/layers';
import {LayersList} from '@deck.gl/core';

import type {TileLoadProps, ZRange} from '../tileset-2d/index';
import {
  Tileset2D,
  Tile2DHeader,
  RefinementStrategy,
  STRATEGY_DEFAULT,
  Tileset2DProps
} from '../tileset-2d/index';
import {urlType, URLTemplate, getURLFromTemplate} from '../tileset-2d/index';

const defaultProps: DefaultProps<TileLayerProps> = {
  TilesetClass: Tileset2D,
  data: {type: 'data', value: []},
  dataComparator: urlType.equal,
  renderSubLayers: {type: 'function', value: (props: any) => new GeoJsonLayer(props)},
  getTileData: {type: 'function', optional: true, value: null},
  // TODO - change to onViewportLoad to align with Tile3DLayer
  onViewportLoad: {type: 'function', optional: true, value: null},
  onTileLoad: {type: 'function', value: tile => {}},
  onTileUnload: {type: 'function', value: tile => {}},
  // eslint-disable-next-line
  onTileError: {type: 'function', value: err => console.error(err)},
  extent: {type: 'array', optional: true, value: null, compare: true},
  tileSize: 512,
  maxZoom: null,
  minZoom: 0,
  maxCacheSize: null,
  maxCacheByteSize: null,
  refinementStrategy: STRATEGY_DEFAULT,
  zRange: null,
  maxRequests: 6,
  debounceTime: 0,
  zoomOffset: 0
};

/** All props supported by the TileLayer */
export type TileLayerProps<DataT = unknown> = CompositeLayerProps & _TileLayerProps<DataT>;

/** Props added by the TileLayer */
type _TileLayerProps<DataT> = {
  data: URLTemplate;
  /**
   * Optionally implement a custom indexing scheme.
   */
  TilesetClass?: typeof Tileset2D;
  /**
   * Renders one or an array of Layer instances.
   */
  renderSubLayers?: (
    props: TileLayerProps<DataT> & {
      id: string;
      data: DataT;
      _offset: number;
      tile: Tile2DHeader<DataT>;
    }
  ) => Layer | null | LayersList;
  /**
   * If supplied, `getTileData` is called to retrieve the data of each tile.
   */
  getTileData?: ((props: TileLoadProps) => Promise<DataT> | DataT) | null;

  /** Called when all tiles in the current viewport are loaded. */
  onViewportLoad?: ((tiles: Tile2DHeader<DataT>[]) => void) | null;

  /** Called when a tile successfully loads. */
  onTileLoad?: (tile: Tile2DHeader<DataT>) => void;

  /** Called when a tile is cleared from cache. */
  onTileUnload?: (tile: Tile2DHeader<DataT>) => void;

  /** Called when a tile failed to load. */
  onTileError?: (err: any, tile?) => void;

  /** The bounding box of the layer's data. */
  extent?: number[] | null;

  /** The pixel dimension of the tiles, usually a power of 2. */
  tileSize?: number;

  /** The max zoom level of the layer's data.
   * @default null
   */
  maxZoom?: number | null;

  /** The min zoom level of the layer's data.
   * @default 0
   */
  minZoom?: number | null;

  /** The maximum number of tiles that can be cached. */
  maxCacheSize?: number | null;

  /**
   * The maximum memory used for caching tiles.
   *
   * @default null
   */
  maxCacheByteSize?: number | null;

  /**
   * How the tile layer refines the visibility of tiles.
   *
   * @default 'best-available'
   */
  refinementStrategy?: RefinementStrategy;

  /** Range of minimum and maximum heights in the tile. */
  zRange?: ZRange | null;

  /**
   * The maximum number of concurrent getTileData calls.
   *
   * @default 6
   */
  maxRequests?: number;

  /**
   * Queue tile requests until no new tiles have been requested for at least `debounceTime` milliseconds.
   *
   * @default 0
   */
  debounceTime?: number;

  /**
   * This offset changes the zoom level at which the tiles are fetched.
   *
   * Needs to be an integer.
   *
   * @default 0
   */
  zoomOffset?: number;
};

export type TileLayerPickingInfo<
  DataT = any,
  SubLayerPickingInfo = PickingInfo
> = SubLayerPickingInfo & {
  /** The picked tile */
  tile?: Tile2DHeader<DataT>;
  /** the tile that emitted the picking event */
  sourceTile: Tile2DHeader<DataT>;
  /** a layer created by props.renderSubLayer() that emitted the picking event */
  sourceTileSubLayer: Layer;
};

/**
 * The TileLayer is a composite layer that makes it possible to visualize very large datasets.
 *
 * Instead of fetching the entire dataset, it only loads and renders what's visible in the current viewport.
 */
export default class TileLayer<DataT = any, ExtraPropsT extends {} = {}> extends CompositeLayer<
  ExtraPropsT & Required<_TileLayerProps<DataT>>
> {
  static defaultProps: DefaultProps = defaultProps;
  static layerName = 'TileLayer';

  state!: {
    tileset: Tileset2D | null;
    isLoaded: boolean;
    frameNumber?: number;
  };

  initializeState() {
    this.state = {
      tileset: null,
      isLoaded: false
    };
  }

  finalizeState() {
    this.state?.tileset?.finalize();
  }

  get isLoaded(): boolean {
    return Boolean(
      this.state?.tileset?.selectedTiles?.every(
        tile => tile.isLoaded && tile.layers && tile.layers.every(layer => layer.isLoaded)
      )
    );
  }

  shouldUpdateState({changeFlags}): boolean {
    return changeFlags.somethingChanged;
  }

  updateState({changeFlags}: UpdateParameters<this>) {
    let {tileset} = this.state;
    const propsChanged = changeFlags.propsOrDataChanged || changeFlags.updateTriggersChanged;
    const dataChanged =
      changeFlags.dataChanged ||
      (changeFlags.updateTriggersChanged &&
        (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getTileData));

    if (!tileset) {
      tileset = new this.props.TilesetClass(this._getTilesetOptions());
      this.setState({tileset});
    } else if (propsChanged) {
      tileset.setOptions(this._getTilesetOptions());

      if (dataChanged) {
        // reload all tiles
        // use cached layers until new content is loaded
        tileset.reloadAll();
      } else {
        // some render options changed, regenerate sub layers now
        tileset.tiles.forEach(tile => {
          tile.layers = null;
        });
      }
    }

    this._updateTileset();
  }

  _getTilesetOptions(): Tileset2DProps {
    const {
      tileSize,
      maxCacheSize,
      maxCacheByteSize,
      refinementStrategy,
      extent,
      maxZoom,
      minZoom,
      maxRequests,
      debounceTime,
      zoomOffset
    } = this.props;

    return {
      maxCacheSize,
      maxCacheByteSize,
      maxZoom,
      minZoom,
      tileSize,
      refinementStrategy,
      extent,
      maxRequests,
      debounceTime,
      zoomOffset,

      getTileData: this.getTileData.bind(this),
      onTileLoad: this._onTileLoad.bind(this),
      onTileError: this._onTileError.bind(this),
      onTileUnload: this._onTileUnload.bind(this)
    };
  }

  private _updateTileset(): void {
    const tileset = this.state.tileset!;
    const {zRange, modelMatrix} = this.props;
    const frameNumber = tileset.update(this.context.viewport, {zRange, modelMatrix});
    const {isLoaded} = tileset;

    const loadingStateChanged = this.state.isLoaded !== isLoaded;
    const tilesetChanged = this.state.frameNumber !== frameNumber;

    if (isLoaded && (loadingStateChanged || tilesetChanged)) {
      this._onViewportLoad();
    }

    if (tilesetChanged) {
      // Save the tileset frame number - trigger a rerender
      this.setState({frameNumber});
    }
    // Save the loaded state - should not trigger a rerender
    this.state.isLoaded = isLoaded;
  }

  _onViewportLoad(): void {
    const {tileset} = this.state;
    const {onViewportLoad} = this.props;

    if (onViewportLoad) {
      // This method can only be called when tileset is defined and updated
      onViewportLoad(tileset!.selectedTiles!);
    }
  }

  _onTileLoad(tile: Tile2DHeader<DataT>): void {
    this.props.onTileLoad(tile);
    tile.layers = null;

    this.setNeedsUpdate();
  }

  _onTileError(error: any, tile: Tile2DHeader<DataT>) {
    this.props.onTileError(error);
    tile.layers = null;

    this.setNeedsUpdate();
  }

  _onTileUnload(tile: Tile2DHeader<DataT>) {
    this.props.onTileUnload(tile);
  }

  // Methods for subclass to override

  getTileData(tile: TileLoadProps): Promise<DataT> | DataT | null {
    const {data, getTileData, fetch} = this.props;
    const {signal} = tile;

    tile.url =
      typeof data === 'string' || Array.isArray(data) ? getURLFromTemplate(data, tile) : null;

    if (getTileData) {
      return getTileData(tile);
    }
    if (fetch && tile.url) {
      return fetch(tile.url, {propName: 'data', layer: this, signal});
    }
    return null;
  }

  renderSubLayers(
    props: TileLayer['props'] & {
      id: string;
      data: DataT;
      _offset: number;
      tile: Tile2DHeader<DataT>;
    }
  ): Layer | null | LayersList {
    return this.props.renderSubLayers(props);
  }

  getSubLayerPropsByTile(tile: Tile2DHeader): Partial<LayerProps> | null {
    return null;
  }

  getPickingInfo(params: GetPickingInfoParams): TileLayerPickingInfo<DataT> {
    // TileLayer does not directly render anything, sourceLayer cannot be null
    const sourceLayer = params.sourceLayer!;
    const sourceTile: Tile2DHeader<DataT> = (sourceLayer.props as any).tile;
    const info = params.info as TileLayerPickingInfo<DataT>;
    if (info.picked) {
      info.tile = sourceTile;
    }
    info.sourceTile = sourceTile;
    info.sourceTileSubLayer = sourceLayer;
    return info;
  }

  protected _updateAutoHighlight(info: TileLayerPickingInfo<DataT>): void {
    info.sourceTileSubLayer.updateAutoHighlight(info);
  }

  renderLayers(): Layer | null | LayersList {
    return this.state.tileset!.tiles.map((tile: Tile2DHeader) => {
      const subLayerProps = this.getSubLayerPropsByTile(tile);
      // cache the rendered layer in the tile
      if (!tile.isLoaded && !tile.content) {
        // nothing to show
      } else if (!tile.layers) {
        const layers = this.renderSubLayers({
          ...this.props,
          ...this.getSubLayerProps({
            id: tile.id,
            updateTriggers: this.props.updateTriggers
          }),
          data: tile.content,
          _offset: 0,
          tile
        });
        tile.layers = (flatten(layers, Boolean) as Layer<{tile?: Tile2DHeader}>[]).map(layer =>
          layer.clone({
            tile,
            ...subLayerProps
          })
        );
      } else if (
        subLayerProps &&
        tile.layers[0] &&
        Object.keys(subLayerProps).some(
          propName => tile.layers![0].props[propName] !== subLayerProps[propName]
        )
      ) {
        tile.layers = tile.layers.map(layer => layer.clone(subLayerProps));
      }
      return tile.layers;
    });
  }

  filterSubLayer({layer, cullRect}: FilterContext) {
    const {tile} = (layer as Layer<{tile: Tile2DHeader}>).props;
    return this.state.tileset!.isTileVisible(tile, cullRect);
  }
}

1	import {	1✔
2	CompositeLayer,	1✔
3	CompositeLayerProps,	1✔
4	Layer,	1✔
5	LayerProps,	1✔
6	UpdateParameters,	1✔
7	PickingInfo,	1✔
8	GetPickingInfoParams,	1✔
9	DefaultProps,	1✔
10	FilterContext,	1✔
11	_flatten as flatten	1✔
12	} from '@deck.gl/core';	1✔
13	import {GeoJsonLayer} from '@deck.gl/layers';	1✔
14	import {LayersList} from '@deck.gl/core';	1✔
15		1✔
16	import type {TileLoadProps, ZRange} from '../tileset-2d/index';	1✔
17	import {	1✔
18	Tileset2D,	1✔
19	Tile2DHeader,	1✔
20	RefinementStrategy,	1✔
21	STRATEGY_DEFAULT,	1✔
22	Tileset2DProps	1✔
23	} from '../tileset-2d/index';	1✔
24	import {urlType, URLTemplate, getURLFromTemplate} from '../tileset-2d/index';	1✔
25		1✔
26	const defaultProps: DefaultProps<TileLayerProps> = {	1✔
27	TilesetClass: Tileset2D,	1✔
28	data: {type: 'data', value: []},	1✔
29	dataComparator: urlType.equal,	1✔
30	renderSubLayers: {type: 'function', value: (props: any) => new GeoJsonLayer(props)},	1✔
31	getTileData: {type: 'function', optional: true, value: null},	1✔
32	// TODO - change to onViewportLoad to align with Tile3DLayer	1✔
33	onViewportLoad: {type: 'function', optional: true, value: null},	1✔
34	onTileLoad: {type: 'function', value: tile => {}},	1✔
35	onTileUnload: {type: 'function', value: tile => {}},	1✔
36	// eslint-disable-next-line	1✔
37	onTileError: {type: 'function', value: err => console.error(err)},	1✔
38	extent: {type: 'array', optional: true, value: null, compare: true},	1✔
39	tileSize: 512,	1✔
40	maxZoom: null,	1✔
41	minZoom: 0,	1✔
42	maxCacheSize: null,	1✔
43	maxCacheByteSize: null,	1✔
44	refinementStrategy: STRATEGY_DEFAULT,	1✔
45	zRange: null,	1✔
46	maxRequests: 6,	1✔
47	debounceTime: 0,	1✔
48	zoomOffset: 0	1✔
49	};	1✔
50		1✔
51	/** All props supported by the TileLayer */	1✔
52	export type TileLayerProps<DataT = unknown> = CompositeLayerProps & _TileLayerProps<DataT>;	1✔
53		1✔
54	/** Props added by the TileLayer */	1✔
55	type _TileLayerProps<DataT> = {	1✔
56	data: URLTemplate;	1✔
57	/**	1✔
58	* Optionally implement a custom indexing scheme.	1✔
59	*/	1✔
60	TilesetClass?: typeof Tileset2D;	1✔
61	/**	1✔
62	* Renders one or an array of Layer instances.	1✔
63	*/	1✔
64	renderSubLayers?: (	1✔
65	props: TileLayerProps<DataT> & {	1✔
66	id: string;	1✔
67	data: DataT;	1✔
68	_offset: number;	1✔
69	tile: Tile2DHeader<DataT>;	1✔
70	}	1✔
71	) => Layer \| null \| LayersList;	1✔
72	/**	1✔
73	* If supplied, `getTileData` is called to retrieve the data of each tile.	1✔
74	*/	1✔
75	getTileData?: ((props: TileLoadProps) => Promise<DataT> \| DataT) \| null;	1✔
76		1✔
77	/** Called when all tiles in the current viewport are loaded. */	1✔
78	onViewportLoad?: ((tiles: Tile2DHeader<DataT>[]) => void) \| null;	1✔
79		1✔
80	/** Called when a tile successfully loads. */	1✔
81	onTileLoad?: (tile: Tile2DHeader<DataT>) => void;	1✔
82		1✔
83	/** Called when a tile is cleared from cache. */	1✔
84	onTileUnload?: (tile: Tile2DHeader<DataT>) => void;	1✔
85		1✔
86	/** Called when a tile failed to load. */	1✔
87	onTileError?: (err: any, tile?) => void;	1✔
88		1✔
89	/** The bounding box of the layer's data. */	1✔
90	extent?: number[] \| null;	1✔
91		1✔
92	/** The pixel dimension of the tiles, usually a power of 2. */	1✔
93	tileSize?: number;	1✔
94		1✔
95	/** The max zoom level of the layer's data.	1✔
96	* @default null	1✔
97	*/	1✔
98	maxZoom?: number \| null;	1✔
99		1✔
100	/** The min zoom level of the layer's data.	1✔
101	* @default 0	1✔
102	*/	1✔
103	minZoom?: number \| null;	1✔
104		1✔
105	/** The maximum number of tiles that can be cached. */	1✔
106	maxCacheSize?: number \| null;	1✔
107		1✔
108	/**	1✔
109	* The maximum memory used for caching tiles.	1✔
110	*	1✔
111	* @default null	1✔
112	*/	1✔
113	maxCacheByteSize?: number \| null;	1✔
114		1✔
115	/**	1✔
116	* How the tile layer refines the visibility of tiles.	1✔
117	*	1✔
118	* @default 'best-available'	1✔
119	*/	1✔
120	refinementStrategy?: RefinementStrategy;	1✔
121		1✔
122	/** Range of minimum and maximum heights in the tile. */	1✔
123	zRange?: ZRange \| null;	1✔
124		1✔
125	/**	1✔
126	* The maximum number of concurrent getTileData calls.	1✔
127	*	1✔
128	* @default 6	1✔
129	*/	1✔
130	maxRequests?: number;	1✔
131		1✔
132	/**	1✔
133	* Queue tile requests until no new tiles have been requested for at least `debounceTime` milliseconds.	1✔
134	*	1✔
135	* @default 0	1✔
136	*/	1✔
137	debounceTime?: number;	1✔
138		1✔
139	/**	1✔
140	* This offset changes the zoom level at which the tiles are fetched.	1✔
141	*	1✔
142	* Needs to be an integer.	1✔
143	*	1✔
144	* @default 0	1✔
145	*/	1✔
146	zoomOffset?: number;	1✔
147	};	1✔
148		1✔
149	export type TileLayerPickingInfo<	1✔
150	DataT = any,	1✔
151	SubLayerPickingInfo = PickingInfo	1✔
152	> = SubLayerPickingInfo & {	1✔
153	/** The picked tile */	1✔
154	tile?: Tile2DHeader<DataT>;	1✔
155	/** the tile that emitted the picking event */	1✔
156	sourceTile: Tile2DHeader<DataT>;	1✔
157	/** a layer created by props.renderSubLayer() that emitted the picking event */	1✔
158	sourceTileSubLayer: Layer;	1✔
159	};	1✔
160		1✔
161	/**	1✔
162	* The TileLayer is a composite layer that makes it possible to visualize very large datasets.	1✔
163	*	1✔
164	* Instead of fetching the entire dataset, it only loads and renders what's visible in the current viewport.	1✔
165	*/	1✔
166	export default class TileLayer<DataT = any, ExtraPropsT extends {} = {}> extends CompositeLayer<	1✔
167	ExtraPropsT & Required<_TileLayerProps<DataT>>	1✔
168	> {	1✔
169	static defaultProps: DefaultProps = defaultProps;	1✔
170	static layerName = 'TileLayer';	1✔
171		1✔
172	state!: {	1✔
173	tileset: Tileset2D \| null;	1✔
174	isLoaded: boolean;	1✔
175	frameNumber?: number;	1✔
176	};	1✔
177		1✔
178	initializeState() {	1✔
179	this.state = {	37✔
180	tileset: null,	37✔
181	isLoaded: false	37✔
182	};	37✔
183	}	37✔
184		1✔
185	finalizeState() {	1✔
186	this.state?.tileset?.finalize();	38✔
187	}	38✔
188		1✔
189	get isLoaded(): boolean {	1✔
190	return Boolean(	225✔
191	this.state?.tileset?.selectedTiles?.every(	225✔
192	tile => tile.isLoaded && tile.layers && tile.layers.every(layer => layer.isLoaded)	225✔
193	)	225✔
194	);	225✔
195	}	225✔
196		1✔
197	shouldUpdateState({changeFlags}): boolean {	1✔
198	return changeFlags.somethingChanged;	90✔
199	}	90✔
200		1✔
201	updateState({changeFlags}: UpdateParameters<this>) {	1✔
202	let {tileset} = this.state;	195✔
203	const propsChanged = changeFlags.propsOrDataChanged \|\| changeFlags.updateTriggersChanged;	195✔
204	const dataChanged =	195✔
205	changeFlags.dataChanged \|\|	195✔
206	(changeFlags.updateTriggersChanged &&	149✔
207	(changeFlags.updateTriggersChanged.all \|\| changeFlags.updateTriggersChanged.getTileData));	4✔
208		195✔
209	if (!tileset) {	195✔
210	tileset = new this.props.TilesetClass(this._getTilesetOptions());	38✔
211	this.setState({tileset});	38✔
212	} else if (propsChanged) {	195✔
213	tileset.setOptions(this._getTilesetOptions());	27✔
214		27✔
215	if (dataChanged) {	27✔
216	// reload all tiles	12✔
217	// use cached layers until new content is loaded	12✔
218	tileset.reloadAll();	12✔
219	} else {	27✔
220	// some render options changed, regenerate sub layers now	15✔
221	tileset.tiles.forEach(tile => {	15✔
222	tile.layers = null;	127✔
223	});	15✔
224	}	15✔
225	}	27✔
226		195✔
227	this._updateTileset();	195✔
228	}	195✔
229		1✔
230	_getTilesetOptions(): Tileset2DProps {	1✔
231	const {	65✔
232	tileSize,	65✔
233	maxCacheSize,	65✔
234	maxCacheByteSize,	65✔
235	refinementStrategy,	65✔
236	extent,	65✔
237	maxZoom,	65✔
238	minZoom,	65✔
239	maxRequests,	65✔
240	debounceTime,	65✔
241	zoomOffset	65✔
242	} = this.props;	65✔
243		65✔
244	return {	65✔
245	maxCacheSize,	65✔
246	maxCacheByteSize,	65✔
247	maxZoom,	65✔
248	minZoom,	65✔
249	tileSize,	65✔
250	refinementStrategy,	65✔
251	extent,	65✔
252	maxRequests,	65✔
253	debounceTime,	65✔
254	zoomOffset,	65✔
255		65✔
256	getTileData: this.getTileData.bind(this),	65✔
257	onTileLoad: this._onTileLoad.bind(this),	65✔
258	onTileError: this._onTileError.bind(this),	65✔
259	onTileUnload: this._onTileUnload.bind(this)	65✔
260	};	65✔
261	}	65✔
262		1✔
263	private _updateTileset(): void {	1✔
264	const tileset = this.state.tileset!;	195✔
265	const {zRange, modelMatrix} = this.props;	195✔
266	const frameNumber = tileset.update(this.context.viewport, {zRange, modelMatrix});	195✔
267	const {isLoaded} = tileset;	195✔
268		195✔
269	const loadingStateChanged = this.state.isLoaded !== isLoaded;	195✔
270	const tilesetChanged = this.state.frameNumber !== frameNumber;	195✔
271		195✔
272	if (isLoaded && (loadingStateChanged \|\| tilesetChanged)) {	195✔
273	this._onViewportLoad();	48✔
274	}	48✔
275		195✔
276	if (tilesetChanged) {	195✔
277	// Save the tileset frame number - trigger a rerender	119✔
278	this.setState({frameNumber});	119✔
279	}	119✔
280	// Save the loaded state - should not trigger a rerender	195✔
281	this.state.isLoaded = isLoaded;	195✔
282	}	195✔
283		1✔
284	_onViewportLoad(): void {	1✔
285	const {tileset} = this.state;	48✔
286	const {onViewportLoad} = this.props;	48✔
287		48✔
288	if (onViewportLoad) {	48✔
289	// This method can only be called when tileset is defined and updated	8✔
290	onViewportLoad(tileset!.selectedTiles!);	8✔
291	}	8✔
292	}	48✔
293		1✔
294	_onTileLoad(tile: Tile2DHeader<DataT>): void {	1✔
295	this.props.onTileLoad(tile);	165✔
296	tile.layers = null;	165✔
297		165✔
298	this.setNeedsUpdate();	165✔
299	}	165✔
300		1✔
301	_onTileError(error: any, tile: Tile2DHeader<DataT>) {	1✔
302	this.props.onTileError(error);	87✔
303	tile.layers = null;	87✔
304		87✔
305	this.setNeedsUpdate();	87✔
306	}	87✔
307		1✔
308	_onTileUnload(tile: Tile2DHeader<DataT>) {	1✔
309	this.props.onTileUnload(tile);	×
310	}	×
311		1✔
312	// Methods for subclass to override	1✔
313		1✔
314	getTileData(tile: TileLoadProps): Promise<DataT> \| DataT \| null {	1✔
315	const {data, getTileData, fetch} = this.props;	103✔
316	const {signal} = tile;	103✔
317		103✔
318	tile.url =	103✔
319	typeof data === 'string' \|\| Array.isArray(data) ? getURLFromTemplate(data, tile) : null;	103✔
320		103✔
321	if (getTileData) {	103✔
322	return getTileData(tile);	85✔
323	}	85✔
324	if (fetch && tile.url) {	103✔
325	return fetch(tile.url, {propName: 'data', layer: this, signal});	6✔
326	}	6✔
327	return null;	12✔
328	}	103✔
329		1✔
330	renderSubLayers(	1✔
331	props: TileLayer['props'] & {	364✔
332	id: string;	364✔
333	data: DataT;	364✔
334	_offset: number;	364✔
335	tile: Tile2DHeader<DataT>;	364✔
336	}	364✔
337	): Layer \| null \| LayersList {	364✔
338	return this.props.renderSubLayers(props);	364✔
339	}	364✔
340		1✔
341	getSubLayerPropsByTile(tile: Tile2DHeader): Partial<LayerProps> \| null {	1✔
342	return null;	693✔
343	}	693✔
344		1✔
345	getPickingInfo(params: GetPickingInfoParams): TileLayerPickingInfo<DataT> {	1✔
346	// TileLayer does not directly render anything, sourceLayer cannot be null	16✔
347	const sourceLayer = params.sourceLayer!;	16✔
348	const sourceTile: Tile2DHeader<DataT> = (sourceLayer.props as any).tile;	16✔
349	const info = params.info as TileLayerPickingInfo<DataT>;	16✔
350	if (info.picked) {	16✔
351	info.tile = sourceTile;	10✔
352	}	10✔
353	info.sourceTile = sourceTile;	16✔
354	info.sourceTileSubLayer = sourceLayer;	16✔
355	return info;	16✔
356	}	16✔
357		1✔
358	protected _updateAutoHighlight(info: TileLayerPickingInfo<DataT>): void {	1✔
NEW 359	info.sourceTileSubLayer.updateAutoHighlight(info);	×
UNCOV 360	}	×
361		1✔
362	renderLayers(): Layer \| null \| LayersList {	1✔
363	return this.state.tileset!.tiles.map((tile: Tile2DHeader) => {	197✔
364	const subLayerProps = this.getSubLayerPropsByTile(tile);	2,136✔
365	// cache the rendered layer in the tile	2,136✔
366	if (!tile.isLoaded && !tile.content) {	2,136✔
367	// nothing to show	1,095✔
368	} else if (!tile.layers) {	2,136✔
369	const layers = this.renderSubLayers({	371✔
370	...this.props,	371✔
371	...this.getSubLayerProps({	371✔
372	id: tile.id,	371✔
373	updateTriggers: this.props.updateTriggers	371✔
374	}),	371✔
375	data: tile.content,	371✔
376	_offset: 0,	371✔
377	tile	371✔
378	});	371✔
379	tile.layers = (flatten(layers, Boolean) as Layer<{tile?: Tile2DHeader}>[]).map(layer =>	371✔
380	layer.clone({	302✔
381	tile,	302✔
382	...subLayerProps	302✔
383	})	302✔
384	);	371✔
385	} else if (	371✔
386	subLayerProps &&	669✔
387	tile.layers[0] &&	436✔
388	Object.keys(subLayerProps).some(	436✔
389	propName => tile.layers![0].props[propName] !== subLayerProps[propName]	436✔
390	)	436✔
391	) {	669✔
392	tile.layers = tile.layers.map(layer => layer.clone(subLayerProps));	49✔
393	}	49✔
394	return tile.layers;	2,135✔
395	});	197✔
396	}	197✔
397		1✔
398	filterSubLayer({layer, cullRect}: FilterContext) {	1✔
399	const {tile} = (layer as Layer<{tile: Tile2DHeader}>).props;	1,134✔
400	return this.state.tileset!.isTileVisible(tile, cullRect);	1,134✔
401	}	1,134✔
402	}	1✔

visgl / deck.gl / 8730869952

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