10543564263

Committed 25 Aug 2024 02:51AM UTC coverage: 57.614% (-31.7%) from 89.292%

Build # 10543564263

Build Type

Pull #8833

github

Committed by

web-flow

Commit Message

Merge 9618fd53d into bc900348b

Pull Request Pull Request #8833: Bump to 9.1.0-alpha

Run Details

1710 of 2234 branches covered (76.54%)

Branch coverage included in aggregate %.

94 of 141 new or added lines in 25 files covered. (66.67%)

20319 existing lines in 272 files now uncovered.

35902 of 63049 relevant lines covered (56.94%)

11.42 hits per line

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

37.93

/modules/carto/src/layers/vector-tile-layer.ts

import {registerLoaders} from '@loaders.gl/core';
import CartoPropertiesTileLoader from './schema/carto-properties-tile-loader';
import CartoVectorTileLoader from './schema/carto-vector-tile-loader';
registerLoaders([CartoPropertiesTileLoader, CartoVectorTileLoader]);

import {DefaultProps} from '@deck.gl/core';
import {ClipExtension} from '@deck.gl/extensions';
import {
  MVTLayer,
  MVTLayerProps,
  TileLayer,
  _getURLFromTemplate,
  _Tile2DHeader,
  _TileLoadProps as TileLoadProps
} from '@deck.gl/geo-layers';
import {GeoJsonLayer} from '@deck.gl/layers';

import type {TilejsonResult} from '../sources/types';
import {TilejsonPropType, injectAccessToken, mergeBoundaryData} from './utils';
import {DEFAULT_TILE_SIZE} from '../constants';

const defaultProps: DefaultProps<VectorTileLayerProps> = {
  ...MVTLayer.defaultProps,
  data: TilejsonPropType,
  dataComparator: TilejsonPropType.equal,
  tileSize: DEFAULT_TILE_SIZE
};

/** All properties supported by VectorTileLayer. */
export type VectorTileLayerProps<FeaturePropertiesT = unknown> = _VectorTileLayerProps &
  Omit<MVTLayerProps<FeaturePropertiesT>, 'data'>;

/** Properties added by VectorTileLayer. */
type _VectorTileLayerProps = {
  data: null | TilejsonResult | Promise<TilejsonResult>;
};

// @ts-ignore
export default class VectorTileLayer<
  FeaturePropertiesT = any,
  ExtraProps extends {} = {}
> extends MVTLayer<FeaturePropertiesT, Required<_VectorTileLayerProps> & ExtraProps> {
  static layerName = 'VectorTileLayer';
  static defaultProps = defaultProps;

  state!: MVTLayer['state'] & {
    mvt: boolean;
  };

  constructor(...propObjects: VectorTileLayerProps<FeaturePropertiesT>[]) {
    // Force externally visible props type, as it is not possible modify via extension
    // @ts-ignore
    super(...propObjects);
  }

  initializeState(): void {
    super.initializeState();
    this.setState({binary: true});
  }

  updateState(parameters) {
    const {props} = parameters;
    if (props.data) {
      super.updateState(parameters);

      const formatTiles = new URL(props.data.tiles[0]).searchParams.get('formatTiles');
      const mvt = formatTiles === 'mvt';
      this.setState({mvt});
    }
  }

  getLoadOptions(): any {
    const loadOptions = super.getLoadOptions() || {};
    const tileJSON = this.props.data as TilejsonResult;
    injectAccessToken(loadOptions, tileJSON.accessToken);
    loadOptions.gis = {format: 'binary'}; // Use binary for MVT loading
    return loadOptions;
  }

  /* eslint-disable camelcase */
  async getTileData(tile: TileLoadProps) {
    const tileJSON = this.props.data as TilejsonResult;
    const {tiles, properties_tiles} = tileJSON;
    const url = _getURLFromTemplate(tiles, tile);
    if (!url) {
      return Promise.reject('Invalid URL');
    }

    const loadOptions = this.getLoadOptions();
    const {fetch} = this.props;
    const {signal} = tile;

    // Fetch geometry and attributes separately
    const geometryFetch = fetch(url, {propName: 'data', layer: this, loadOptions, signal});

    if (!properties_tiles) {
      return await geometryFetch;
    }

    const propertiesUrl = _getURLFromTemplate(properties_tiles, tile);
    if (!propertiesUrl) {
      return Promise.reject('Invalid properties URL');
    }

    const attributesFetch = fetch(propertiesUrl, {
      propName: 'data',
      layer: this,
      loadOptions,
      signal
    });
    const [geometry, attributes] = await Promise.all([geometryFetch, attributesFetch]);
    if (!geometry) return null;

    return attributes ? mergeBoundaryData(geometry, attributes) : geometry;
  }
  /* eslint-enable camelcase */

  renderSubLayers(
    props: TileLayer['props'] & {
      id: string;
      data: any;
      _offset: number;
      tile: _Tile2DHeader;
    }
  ): GeoJsonLayer | null {
    if (props.data === null) {
      return null;
    }

    if (this.state.mvt) {
      return super.renderSubLayers(props) as GeoJsonLayer;
    }

    const tileBbox = props.tile.bbox as any;
    const {west, south, east, north} = tileBbox;

    const extensions = [new ClipExtension(), ...(props.extensions || [])];
    const clipProps = {
      clipBounds: [west, south, east, north]
    };

    const applyClipExtensionToSublayerProps = (subLayerId: string) => {
      return {
        [subLayerId]: {
          ...clipProps,
          ...props?._subLayerProps?.[subLayerId],
          extensions: [...extensions, ...(props?._subLayerProps?.[subLayerId]?.extensions || [])]
        }
      };
    };

    const subLayerProps = {
      ...props,
      autoHighlight: false,
      // Do not perform clipping on points (#9059)
      _subLayerProps: {
        ...props._subLayerProps,
        ...applyClipExtensionToSublayerProps('polygons-fill'),
        ...applyClipExtensionToSublayerProps('polygons-stroke'),
        ...applyClipExtensionToSublayerProps('linestrings')
      }
    };

    const subLayer = new GeoJsonLayer(subLayerProps);
    return subLayer;
  }

  protected override _isWGS84(): boolean {
    // CARTO binary tile coordinates are [lng, lat], not tile-relative like MVT.
    if (this.state.mvt) return super._isWGS84();
    return true;
  }
}

1	import {registerLoaders} from '@loaders.gl/core';	1✔
2	import CartoPropertiesTileLoader from './schema/carto-properties-tile-loader';	1✔
3	import CartoVectorTileLoader from './schema/carto-vector-tile-loader';	1✔
4	registerLoaders([CartoPropertiesTileLoader, CartoVectorTileLoader]);	1✔
5		1✔
6	import {DefaultProps} from '@deck.gl/core';	1✔
7	import {ClipExtension} from '@deck.gl/extensions';	1✔
8	import {	1✔
9	MVTLayer,	1✔
10	MVTLayerProps,	1✔
11	TileLayer,	1✔
12	_getURLFromTemplate,	1✔
13	_Tile2DHeader,	1✔
14	_TileLoadProps as TileLoadProps	1✔
15	} from '@deck.gl/geo-layers';	1✔
16	import {GeoJsonLayer} from '@deck.gl/layers';	1✔
17		1✔
18	import type {TilejsonResult} from '../sources/types';	1✔
19	import {TilejsonPropType, injectAccessToken, mergeBoundaryData} from './utils';	1✔
20	import {DEFAULT_TILE_SIZE} from '../constants';	1✔
21		1✔
22	const defaultProps: DefaultProps<VectorTileLayerProps> = {	1✔
23	...MVTLayer.defaultProps,	1✔
24	data: TilejsonPropType,	1✔
25	dataComparator: TilejsonPropType.equal,	1✔
26	tileSize: DEFAULT_TILE_SIZE	1✔
27	};	1✔
28		1✔
29	/** All properties supported by VectorTileLayer. */	1✔
30	export type VectorTileLayerProps<FeaturePropertiesT = unknown> = _VectorTileLayerProps &	1✔
31	Omit<MVTLayerProps<FeaturePropertiesT>, 'data'>;	1✔
32		1✔
33	/** Properties added by VectorTileLayer. */	1✔
34	type _VectorTileLayerProps = {	1✔
35	data: null \| TilejsonResult \| Promise<TilejsonResult>;	1✔
36	};	1✔
37		1✔
38	// @ts-ignore	1✔
39	export default class VectorTileLayer<	1✔
40	FeaturePropertiesT = any,	1✔
41	ExtraProps extends {} = {}	1✔
42	> extends MVTLayer<FeaturePropertiesT, Required<_VectorTileLayerProps> & ExtraProps> {	1✔
43	static layerName = 'VectorTileLayer';	1✔
44	static defaultProps = defaultProps;	1✔
45		1✔
46	state!: MVTLayer['state'] & {	1✔
47	mvt: boolean;	1✔
48	};	1✔
49		1✔
50	constructor(...propObjects: VectorTileLayerProps<FeaturePropertiesT>[]) {	1✔
UNCOV 51	// Force externally visible props type, as it is not possible modify via extension	×
UNCOV 52	// @ts-ignore	×
UNCOV 53	super(...propObjects);	×
UNCOV 54	}	×
55		1✔
56	initializeState(): void {	1✔
UNCOV 57	super.initializeState();	×
UNCOV 58	this.setState({binary: true});	×
UNCOV 59	}	×
60		1✔
61	updateState(parameters) {	1✔
UNCOV 62	const {props} = parameters;	×
UNCOV 63	if (props.data) {	×
UNCOV 64	super.updateState(parameters);	×
UNCOV 65		×
UNCOV 66	const formatTiles = new URL(props.data.tiles[0]).searchParams.get('formatTiles');	×
UNCOV 67	const mvt = formatTiles === 'mvt';	×
UNCOV 68	this.setState({mvt});	×
UNCOV 69	}	×
UNCOV 70	}	×
71		1✔
72	getLoadOptions(): any {	1✔
73	const loadOptions = super.getLoadOptions() \|\| {};	×
74	const tileJSON = this.props.data as TilejsonResult;	×
75	injectAccessToken(loadOptions, tileJSON.accessToken);	×
76	loadOptions.gis = {format: 'binary'}; // Use binary for MVT loading	×
77	return loadOptions;	×
78	}	×
79		1✔
80	/* eslint-disable camelcase */	1✔
81	async getTileData(tile: TileLoadProps) {	1✔
82	const tileJSON = this.props.data as TilejsonResult;	×
83	const {tiles, properties_tiles} = tileJSON;	×
84	const url = _getURLFromTemplate(tiles, tile);	×
85	if (!url) {	×
86	return Promise.reject('Invalid URL');	×
87	}	×
88		×
89	const loadOptions = this.getLoadOptions();	×
90	const {fetch} = this.props;	×
91	const {signal} = tile;	×
92		×
93	// Fetch geometry and attributes separately	×
94	const geometryFetch = fetch(url, {propName: 'data', layer: this, loadOptions, signal});	×
95		×
96	if (!properties_tiles) {	×
97	return await geometryFetch;	×
98	}	×
99		×
100	const propertiesUrl = _getURLFromTemplate(properties_tiles, tile);	×
101	if (!propertiesUrl) {	×
102	return Promise.reject('Invalid properties URL');	×
103	}	×
104		×
105	const attributesFetch = fetch(propertiesUrl, {	×
106	propName: 'data',	×
107	layer: this,	×
108	loadOptions,	×
109	signal	×
110	});	×
111	const [geometry, attributes] = await Promise.all([geometryFetch, attributesFetch]);	×
112	if (!geometry) return null;	×
113		×
114	return attributes ? mergeBoundaryData(geometry, attributes) : geometry;	×
115	}	×
116	/* eslint-enable camelcase */	1✔
117		1✔
118	renderSubLayers(	1✔
UNCOV 119	props: TileLayer['props'] & {	×
UNCOV 120	id: string;	×
UNCOV 121	data: any;	×
UNCOV 122	_offset: number;	×
UNCOV 123	tile: _Tile2DHeader;	×
UNCOV 124	}	×
UNCOV 125	): GeoJsonLayer \| null {	×
UNCOV 126	if (props.data === null) {	×
127	return null;	×
128	}	×
UNCOV 129		×
UNCOV 130	if (this.state.mvt) {	×
UNCOV 131	return super.renderSubLayers(props) as GeoJsonLayer;	×
UNCOV 132	}	×
UNCOV 133		×
UNCOV 134	const tileBbox = props.tile.bbox as any;	×
UNCOV 135	const {west, south, east, north} = tileBbox;	×
UNCOV 136		×
UNCOV 137	const extensions = [new ClipExtension(), ...(props.extensions \|\| [])];	×
UNCOV 138	const clipProps = {	×
UNCOV 139	clipBounds: [west, south, east, north]	×
UNCOV 140	};	×
UNCOV 141		×
UNCOV 142	const applyClipExtensionToSublayerProps = (subLayerId: string) => {	×
UNCOV 143	return {	×
UNCOV 144	[subLayerId]: {	×
UNCOV 145	...clipProps,	×
UNCOV 146	...props?._subLayerProps?.[subLayerId],	×
UNCOV 147	extensions: [...extensions, ...(props?._subLayerProps?.[subLayerId]?.extensions \|\| [])]	×
UNCOV 148	}	×
UNCOV 149	};	×
UNCOV 150	};	×
UNCOV 151		×
UNCOV 152	const subLayerProps = {	×
UNCOV 153	...props,	×
UNCOV 154	autoHighlight: false,	×
UNCOV 155	// Do not perform clipping on points (#9059)	×
UNCOV 156	_subLayerProps: {	×
UNCOV 157	...props._subLayerProps,	×
UNCOV 158	...applyClipExtensionToSublayerProps('polygons-fill'),	×
UNCOV 159	...applyClipExtensionToSublayerProps('polygons-stroke'),	×
UNCOV 160	...applyClipExtensionToSublayerProps('linestrings')	×
UNCOV 161	}	×
UNCOV 162	};	×
UNCOV 163		×
UNCOV 164	const subLayer = new GeoJsonLayer(subLayerProps);	×
UNCOV 165	return subLayer;	×
UNCOV 166	}	×
167		1✔
168	protected override _isWGS84(): boolean {	1✔
UNCOV 169	// CARTO binary tile coordinates are [lng, lat], not tile-relative like MVT.	×
UNCOV 170	if (this.state.mvt) return super._isWGS84();	×
UNCOV 171	return true;	×
UNCOV 172	}	×
173	}	1✔

visgl / deck.gl / 10543564263

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