8970341128

Committed 06 May 2024 01:58PM UTC coverage: 89.707% (-0.1%) from 89.807%

Build # 8970341128

Build Type

Pull #8856

github

Committed by

web-flow

Commit Message

Merge f8ec0c8e6 into 280a07d65

Pull Request Pull Request #8856: Carto: fetchMap to support custom basemaps

Run Details

6313 of 6949 branches covered (90.85%)

Branch coverage included in aggregate %.

60 of 142 new or added lines in 5 files covered. (42.25%)

21 existing lines in 1 file now uncovered.

52052 of 58113 relevant lines covered (89.57%)

6626.27 hits per line

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

91.05

/modules/carto/src/api/parse-map.ts

import {GL} from '@luma.gl/constants';
import {log} from '@deck.gl/core';
import {
  AGGREGATION,
  getLayer,
  getColorAccessor,
  getColorValueAccessor,
  getSizeAccessor,
  getTextAccessor,
  OPACITY_MAP,
  opacityToAlpha,
  getIconUrlAccessor,
  negateAccessor,
  getMaxMarkerSize
} from './layer-map';
import PointLabelLayer from '../layers/point-label-layer';
import {CollisionFilterExtension} from '@deck.gl/extensions';
import {assert} from '../utils';
import {KeplerMapConfig, MapDataset, MapLayerConfig, VisualChannels} from './types';

const collisionFilterExtension = new CollisionFilterExtension();

export function parseMap(json) {
  const {keplerMapConfig, datasets, token} = json;
  assert(keplerMapConfig.version === 'v1', 'Only support Kepler v1');
  const {mapState, mapStyle} = keplerMapConfig.config as KeplerMapConfig;
  const {layers, layerBlending, interactionConfig} = keplerMapConfig.config.visState;

  return {
    id: json.id,
    title: json.title,
    description: json.description,
    createdAt: json.createdAt,
    updatedAt: json.updatedAt,
    initialViewState: mapState,
    mapStyle,
    token,
    layers: layers.reverse().map(({id, type, config, visualChannels}) => {
      try {
        const {dataId} = config;
        const dataset: MapDataset | null = datasets.find(d => d.id === dataId);
        assert(dataset, `No dataset matching dataId: ${dataId}`);
        const {data} = dataset;
        assert(data, `No data loaded for dataId: ${dataId}`);
        const {Layer, propMap, defaultProps} = getLayer(type, config, dataset);
        const styleProps = createStyleProps(config, propMap);
        return new Layer({
          id,
          data,
          ...defaultProps,
          ...createInteractionProps(interactionConfig),
          ...styleProps,
          ...createChannelProps(id, type, config, visualChannels, data), // Must come after style
          ...createParametersProp(layerBlending, styleProps.parameters || {}), // Must come after style
          ...createLoadOptions(token)
        });
      } catch (e: any) {
        log.error(e.message)();
        return undefined;
      }
    })
  };
}

function createParametersProp(layerBlending, parameters: Record<string, any>) {
  if (layerBlending === 'additive') {
    parameters.blendFunc = [GL.SRC_ALPHA, GL.DST_ALPHA];
    parameters.blendEquation = GL.FUNC_ADD;
  } else if (layerBlending === 'subtractive') {
    parameters.blendFunc = [GL.ONE, GL.ONE_MINUS_DST_COLOR, GL.SRC_ALPHA, GL.DST_ALPHA];
    parameters.blendEquation = [GL.FUNC_SUBTRACT, GL.FUNC_ADD];
  }

  return Object.keys(parameters).length ? {parameters} : {};
}

function createInteractionProps(interactionConfig) {
  const pickable = interactionConfig && interactionConfig.tooltip.enabled;
  return {
    autoHighlight: pickable,
    pickable
  };
}

function mapProps(source, target, mapping) {
  for (const sourceKey in mapping) {
    const sourceValue = source[sourceKey];
    const targetKey = mapping[sourceKey];
    if (sourceValue === undefined) {
      // eslint-disable-next-line no-continue
      continue;
    }
    if (typeof targetKey === 'string') {
      target[targetKey] = sourceValue;
    } else if (typeof targetKey === 'function') {
      const [key, value] = Object.entries(targetKey(sourceValue))[0];
      target[key] = value;
    } else if (typeof targetKey === 'object') {
      // Nested definition, recurse down one level (also handles arrays)
      mapProps(sourceValue, target, targetKey);
    }
  }
}

function createStyleProps(config: MapLayerConfig, mapping) {
  const result: Record<string, any> = {};
  mapProps(config, result, mapping);

  // Kepler format sometimes omits strokeColor. TODO: remove once we can rely on
  // `strokeColor` always being set when `stroke: true`.
  if (result.stroked && !result.getLineColor) {
    result.getLineColor = result.getFillColor;
  }

  for (const colorAccessor in OPACITY_MAP) {
    if (Array.isArray(result[colorAccessor])) {
      const color = [...result[colorAccessor]];
      const opacityKey = OPACITY_MAP[colorAccessor];
      const opacity = config.visConfig[opacityKey];
      color[3] = opacityToAlpha(opacity);
      result[colorAccessor] = color;
    }
  }

  result.highlightColor = config.visConfig.enable3d ? [255, 255, 255, 60] : [252, 242, 26, 255];
  return result;
}

/* eslint-disable complexity, max-statements */
function createChannelProps(
  id: string,
  type: string,
  config: MapLayerConfig,
  visualChannels: VisualChannels,
  data
) {
  const {
    colorField,
    colorScale,
    radiusField,
    radiusScale,
    sizeField,
    sizeScale,
    strokeColorField,
    strokeColorScale
  } = visualChannels;
  let {heightField, heightScale} = visualChannels;
  if (type === 'hexagonId') {
    heightField = sizeField;
    heightScale = sizeScale;
  }
  const {textLabel, visConfig} = config;
  const result: Record<string, any> = {};

  if (type === 'grid' || type === 'hexagon') {
    result.colorScaleType = colorScale;
    if (colorField) {
      const {colorAggregation} = config.visConfig;
      if (!AGGREGATION[colorAggregation]) {
        result.getColorValue = getColorValueAccessor(colorField, colorAggregation, data);
      } else {
        result.getColorWeight = d => d[colorField.name];
      }
    }
  } else if (colorField) {
    const {colorAggregation: aggregation, colorRange: range} = visConfig;
    result.getFillColor = getColorAccessor(
      colorField,
      // @ts-ignore
      colorScale,
      {aggregation, range},
      visConfig.opacity,
      data
    );
  }

  if (type === 'point') {
    const altitude = config.columns?.altitude;
    if (altitude) {
      result.dataTransform = data => {
        data.features.forEach(({geometry, properties}) => {
          const {type, coordinates} = geometry;
          if (type === 'Point') {
            coordinates[2] = properties[altitude];
          }
        });
        return data;
      };
    }
  }

  if (radiusField || sizeField) {
    result.getPointRadius = getSizeAccessor(
      // @ts-ignore
      radiusField || sizeField,
      // @ts-ignore
      radiusScale || sizeScale,
      visConfig.sizeAggregation,
      visConfig.radiusRange || visConfig.sizeRange,
      data
    );
  }

  if (strokeColorField) {
    const fallbackOpacity = type === 'point' ? visConfig.opacity : 1;
    const opacity =
      visConfig.strokeOpacity !== undefined ? visConfig.strokeOpacity : fallbackOpacity;
    const {strokeColorAggregation: aggregation, strokeColorRange: range} = visConfig;
    result.getLineColor = getColorAccessor(
      strokeColorField,
      // @ts-ignore
      strokeColorScale,
      // @ts-ignore
      {aggregation, range},
      opacity,
      data
    );
  }

  if (heightField && visConfig.enable3d) {
    result.getElevation = getSizeAccessor(
      heightField,
      // @ts-ignore
      heightScale,
      visConfig.heightAggregation,
      visConfig.heightRange || visConfig.sizeRange,
      data
    );
  }

  if (visConfig.customMarkers) {
    const maxIconSize = getMaxMarkerSize(visConfig, visualChannels);
    const {getPointRadius, getFillColor} = result;
    const {customMarkersUrl, customMarkersRange, filled: useMaskedIcons} = visConfig;

    result.pointType = 'icon';
    result.getIcon = getIconUrlAccessor(
      visualChannels.customMarkersField,
      customMarkersRange,
      {fallbackUrl: customMarkersUrl, maxIconSize, useMaskedIcons},
      data
    );
    result._subLayerProps = {
      'points-icon': {
        loadOptions: {
          image: {
            type: 'imagebitmap'
          },
          imagebitmap: {
            resizeWidth: maxIconSize,
            resizeHeight: maxIconSize,
            resizeQuality: 'high'
          }
        }
      }
    };

    if (getFillColor && useMaskedIcons) {
      result.getIconColor = getFillColor;
    }

    if (getPointRadius) {
      result.getIconSize = getPointRadius;
    }

    if (visualChannels.rotationField) {
      result.getIconAngle = negateAccessor(
        getSizeAccessor(visualChannels.rotationField, undefined, null, undefined, data)
      );
    }
  } else if (type === 'point' || type === 'tileset') {
    result.pointType = 'circle';
  }

  if (textLabel && textLabel.length && textLabel[0].field) {
    const [mainLabel, secondaryLabel] = textLabel;
    const collisionGroup = id;

    ({
      alignment: result.getTextAlignmentBaseline,
      anchor: result.getTextAnchor,
      color: result.getTextColor,
      outlineColor: result.textOutlineColor,
      size: result.textSizeScale
    } = mainLabel);
    const {
      color: getSecondaryColor,
      field: secondaryField,
      outlineColor: secondaryOutlineColor,
      size: secondarySizeScale
    } = secondaryLabel || {};

    result.getText = mainLabel.field && getTextAccessor(mainLabel.field, data);
    const getSecondaryText = secondaryField && getTextAccessor(secondaryField, data);

    result.pointType = `${result.pointType}+text`;
    result.textCharacterSet = 'auto';
    result.textFontFamily = 'Inter, sans';
    result.textFontSettings = {sdf: true};
    result.textFontWeight = 600;
    result.textOutlineWidth = 3;

    result._subLayerProps = {
      ...result._subLayerProps,
      'points-text': {
        type: PointLabelLayer,
        extensions: [collisionFilterExtension],
        collisionEnabled: true,
        collisionGroup,

        // getPointRadius already has radiusScale baked in, so only pass one or the other
        ...(result.getPointRadius
          ? {getRadius: result.getPointRadius}
          : {radiusScale: visConfig.radius}),

        ...(secondaryField && {
          getSecondaryText,
          getSecondaryColor,
          secondarySizeScale,
          secondaryOutlineColor
        })
      }
    };
  }

  return result;
}

function createLoadOptions(accessToken: string) {
  return {
    loadOptions: {fetch: {headers: {Authorization: `Bearer ${accessToken}`}}}
  };
}

1	import {GL} from '@luma.gl/constants';	1✔
2	import {log} from '@deck.gl/core';	1✔
3	import {	1✔
4	AGGREGATION,	1✔
5	getLayer,	1✔
6	getColorAccessor,	1✔
7	getColorValueAccessor,	1✔
8	getSizeAccessor,	1✔
9	getTextAccessor,	1✔
10	OPACITY_MAP,	1✔
11	opacityToAlpha,	1✔
12	getIconUrlAccessor,	1✔
13	negateAccessor,	1✔
14	getMaxMarkerSize	1✔
15	} from './layer-map';	1✔
16	import PointLabelLayer from '../layers/point-label-layer';	1✔
17	import {CollisionFilterExtension} from '@deck.gl/extensions';	1✔
18	import {assert} from '../utils';	1✔
19	import {KeplerMapConfig, MapDataset, MapLayerConfig, VisualChannels} from './types';	1✔
20		1✔
21	const collisionFilterExtension = new CollisionFilterExtension();	1✔
22		1✔
23	export function parseMap(json) {	1✔
24	const {keplerMapConfig, datasets, token} = json;	17✔
25	assert(keplerMapConfig.version === 'v1', 'Only support Kepler v1');	17✔
26	const {mapState, mapStyle} = keplerMapConfig.config as KeplerMapConfig;	17✔
27	const {layers, layerBlending, interactionConfig} = keplerMapConfig.config.visState;	17✔
28		17✔
29	return {	17✔
30	id: json.id,	17✔
31	title: json.title,	17✔
32	description: json.description,	17✔
33	createdAt: json.createdAt,	17✔
34	updatedAt: json.updatedAt,	17✔
35	initialViewState: mapState,	17✔
36	mapStyle,	17✔
37	token,	17✔
38	layers: layers.reverse().map(({id, type, config, visualChannels}) => {	17✔
39	try {	17✔
40	const {dataId} = config;	17✔
41	const dataset: MapDataset \| null = datasets.find(d => d.id === dataId);	17✔
42	assert(dataset, `No dataset matching dataId: ${dataId}`);	17✔
43	const {data} = dataset;	17✔
44	assert(data, `No data loaded for dataId: ${dataId}`);	17✔
45	const {Layer, propMap, defaultProps} = getLayer(type, config, dataset);	17✔
46	const styleProps = createStyleProps(config, propMap);	17✔
47	return new Layer({	17✔
48	id,	17✔
49	data,	17✔
50	...defaultProps,	17✔
51	...createInteractionProps(interactionConfig),	17✔
52	...styleProps,	17✔
53	...createChannelProps(id, type, config, visualChannels, data), // Must come after style	17✔
54	...createParametersProp(layerBlending, styleProps.parameters \|\| {}), // Must come after style	17✔
55	...createLoadOptions(token)	17✔
56	});	17✔
57	} catch (e: any) {	17✔
58	log.error(e.message)();	1✔
59	return undefined;	1✔
60	}	1✔
61	})	17✔
62	};	17✔
63	}	17✔
64		1✔
65	function createParametersProp(layerBlending, parameters: Record<string, any>) {	16✔
66	if (layerBlending === 'additive') {	16✔
67	parameters.blendFunc = [GL.SRC_ALPHA, GL.DST_ALPHA];	4✔
68	parameters.blendEquation = GL.FUNC_ADD;	4✔
69	} else if (layerBlending === 'subtractive') {	16✔
70	parameters.blendFunc = [GL.ONE, GL.ONE_MINUS_DST_COLOR, GL.SRC_ALPHA, GL.DST_ALPHA];	5✔
71	parameters.blendEquation = [GL.FUNC_SUBTRACT, GL.FUNC_ADD];	5✔
72	}	5✔
73		16✔
74	return Object.keys(parameters).length ? {parameters} : {};	16✔
75	}	16✔
76		1✔
77	function createInteractionProps(interactionConfig) {	16✔
78	const pickable = interactionConfig && interactionConfig.tooltip.enabled;	16✔
79	return {	16✔
80	autoHighlight: pickable,	16✔
81	pickable	16✔
82	};	16✔
83	}	16✔
84		1✔
85	function mapProps(source, target, mapping) {	59✔
86	for (const sourceKey in mapping) {	59✔
87	const sourceValue = source[sourceKey];	317✔
88	const targetKey = mapping[sourceKey];	317✔
89	if (sourceValue === undefined) {	317✔
90	// eslint-disable-next-line no-continue	107✔
91	continue;	107✔
92	}	107✔
93	if (typeof targetKey === 'string') {	317✔
94	target[targetKey] = sourceValue;	154✔
95	} else if (typeof targetKey === 'function') {	317✔
96	const [key, value] = Object.entries(targetKey(sourceValue))[0];	13✔
97	target[key] = value;	13✔
98	} else if (typeof targetKey === 'object') {	56✔
99	// Nested definition, recurse down one level (also handles arrays)	43✔
100	mapProps(sourceValue, target, targetKey);	43✔
101	}	43✔
102	}	317✔
103	}	59✔
104		1✔
105	function createStyleProps(config: MapLayerConfig, mapping) {	16✔
106	const result: Record<string, any> = {};	16✔
107	mapProps(config, result, mapping);	16✔
108		16✔
109	// Kepler format sometimes omits strokeColor. TODO: remove once we can rely on	16✔
110	// `strokeColor` always being set when `stroke: true`.	16✔
111	if (result.stroked && !result.getLineColor) {	16!
UNCOV 112	result.getLineColor = result.getFillColor;	×
UNCOV 113	}	×
114		16✔
115	for (const colorAccessor in OPACITY_MAP) {	16✔
116	if (Array.isArray(result[colorAccessor])) {	48✔
117	const color = [...result[colorAccessor]];	23✔
118	const opacityKey = OPACITY_MAP[colorAccessor];	23✔
119	const opacity = config.visConfig[opacityKey];	23✔
120	color[3] = opacityToAlpha(opacity);	23✔
121	result[colorAccessor] = color;	23✔
122	}	23✔
123	}	48✔
124		16✔
125	result.highlightColor = config.visConfig.enable3d ? [255, 255, 255, 60] : [252, 242, 26, 255];	16✔
126	return result;	16✔
127	}	16✔
128		1✔
129	/* eslint-disable complexity, max-statements */	1✔
130	function createChannelProps(	16✔
131	id: string,	16✔
132	type: string,	16✔
133	config: MapLayerConfig,	16✔
134	visualChannels: VisualChannels,	16✔
135	data	16✔
136	) {	16✔
137	const {	16✔
138	colorField,	16✔
139	colorScale,	16✔
140	radiusField,	16✔
141	radiusScale,	16✔
142	sizeField,	16✔
143	sizeScale,	16✔
144	strokeColorField,	16✔
145	strokeColorScale	16✔
146	} = visualChannels;	16✔
147	let {heightField, heightScale} = visualChannels;	16✔
148	if (type === 'hexagonId') {	16✔
149	heightField = sizeField;	1✔
150	heightScale = sizeScale;	1✔
151	}	1✔
152	const {textLabel, visConfig} = config;	16✔
153	const result: Record<string, any> = {};	16✔
154		16✔
155	if (type === 'grid' \|\| type === 'hexagon') {	16✔
156	result.colorScaleType = colorScale;	2✔
157	if (colorField) {	2!
UNCOV 158	const {colorAggregation} = config.visConfig;	×
UNCOV 159	if (!AGGREGATION[colorAggregation]) {	×
UNCOV 160	result.getColorValue = getColorValueAccessor(colorField, colorAggregation, data);	×
UNCOV 161	} else {	×
UNCOV 162	result.getColorWeight = d => d[colorField.name];	×
UNCOV 163	}	×
UNCOV 164	}	×
165	} else if (colorField) {	16✔
166	const {colorAggregation: aggregation, colorRange: range} = visConfig;	5✔
167	result.getFillColor = getColorAccessor(	5✔
168	colorField,	5✔
169	// @ts-ignore	5✔
170	colorScale,	5✔
171	{aggregation, range},	5✔
172	visConfig.opacity,	5✔
173	data	5✔
174	);	5✔
175	}	5✔
176		16✔
177	if (type === 'point') {	16✔
178	const altitude = config.columns?.altitude;	5✔
179	if (altitude) {	5✔
180	result.dataTransform = data => {	1✔
181	data.features.forEach(({geometry, properties}) => {	×
182	const {type, coordinates} = geometry;	×
183	if (type === 'Point') {	×
184	coordinates[2] = properties[altitude];	×
185	}	×
UNCOV 186	});	×
UNCOV 187	return data;	×
UNCOV 188	};	×
189	}	1✔
190	}	5✔
191		16✔
192	if (radiusField \|\| sizeField) {	16✔
193	result.getPointRadius = getSizeAccessor(	1✔
194	// @ts-ignore	1✔
195	radiusField \|\| sizeField,	1✔
196	// @ts-ignore	1✔
197	radiusScale \|\| sizeScale,	1✔
198	visConfig.sizeAggregation,	1✔
199	visConfig.radiusRange \|\| visConfig.sizeRange,	1✔
200	data	1✔
201	);	1✔
202	}	1✔
203		16✔
204	if (strokeColorField) {	16✔
205	const fallbackOpacity = type === 'point' ? visConfig.opacity : 1;	4!
206	const opacity =	4✔
207	visConfig.strokeOpacity !== undefined ? visConfig.strokeOpacity : fallbackOpacity;	4!
208	const {strokeColorAggregation: aggregation, strokeColorRange: range} = visConfig;	4✔
209	result.getLineColor = getColorAccessor(	4✔
210	strokeColorField,	4✔
211	// @ts-ignore	4✔
212	strokeColorScale,	4✔
213	// @ts-ignore	4✔
214	{aggregation, range},	4✔
215	opacity,	4✔
216	data	4✔
217	);	4✔
218	}	4✔
219		16✔
220	if (heightField && visConfig.enable3d) {	16✔
221	result.getElevation = getSizeAccessor(	1✔
222	heightField,	1✔
223	// @ts-ignore	1✔
224	heightScale,	1✔
225	visConfig.heightAggregation,	1✔
226	visConfig.heightRange \|\| visConfig.sizeRange,	1✔
227	data	1✔
228	);	1✔
229	}	1✔
230		16✔
231	if (visConfig.customMarkers) {	16✔
232	const maxIconSize = getMaxMarkerSize(visConfig, visualChannels);	2✔
233	const {getPointRadius, getFillColor} = result;	2✔
234	const {customMarkersUrl, customMarkersRange, filled: useMaskedIcons} = visConfig;	2✔
235		2✔
236	result.pointType = 'icon';	2✔
237	result.getIcon = getIconUrlAccessor(	2✔
238	visualChannels.customMarkersField,	2✔
239	customMarkersRange,	2✔
240	{fallbackUrl: customMarkersUrl, maxIconSize, useMaskedIcons},	2✔
241	data	2✔
242	);	2✔
243	result._subLayerProps = {	2✔
244	'points-icon': {	2✔
245	loadOptions: {	2✔
246	image: {	2✔
247	type: 'imagebitmap'	2✔
248	},	2✔
249	imagebitmap: {	2✔
250	resizeWidth: maxIconSize,	2✔
251	resizeHeight: maxIconSize,	2✔
252	resizeQuality: 'high'	2✔
253	}	2✔
254	}	2✔
255	}	2✔
256	};	2✔
257		2✔
258	if (getFillColor && useMaskedIcons) {	2!
UNCOV 259	result.getIconColor = getFillColor;	×
UNCOV 260	}	×
261		2✔
262	if (getPointRadius) {	2!
UNCOV 263	result.getIconSize = getPointRadius;	×
UNCOV 264	}	×
265		2✔
266	if (visualChannels.rotationField) {	2!
UNCOV 267	result.getIconAngle = negateAccessor(	×
UNCOV 268	getSizeAccessor(visualChannels.rotationField, undefined, null, undefined, data)	×
UNCOV 269	);	×
UNCOV 270	}	×
271	} else if (type === 'point' \|\| type === 'tileset') {	16✔
272	result.pointType = 'circle';	5✔
273	}	5✔
274		16✔
275	if (textLabel && textLabel.length && textLabel[0].field) {	16✔
276	const [mainLabel, secondaryLabel] = textLabel;	2✔
277	const collisionGroup = id;	2✔
278		2✔
279	({	2✔
280	alignment: result.getTextAlignmentBaseline,	2✔
281	anchor: result.getTextAnchor,	2✔
282	color: result.getTextColor,	2✔
283	outlineColor: result.textOutlineColor,	2✔
284	size: result.textSizeScale	2✔
285	} = mainLabel);	2✔
286	const {	2✔
287	color: getSecondaryColor,	2✔
288	field: secondaryField,	2✔
289	outlineColor: secondaryOutlineColor,	2✔
290	size: secondarySizeScale	2✔
291	} = secondaryLabel \|\| {};	2✔
292		2✔
293	result.getText = mainLabel.field && getTextAccessor(mainLabel.field, data);	2✔
294	const getSecondaryText = secondaryField && getTextAccessor(secondaryField, data);	2✔
295		2✔
296	result.pointType = `${result.pointType}+text`;	2✔
297	result.textCharacterSet = 'auto';	2✔
298	result.textFontFamily = 'Inter, sans';	2✔
299	result.textFontSettings = {sdf: true};	2✔
300	result.textFontWeight = 600;	2✔
301	result.textOutlineWidth = 3;	2✔
302		2✔
303	result._subLayerProps = {	2✔
304	...result._subLayerProps,	2✔
305	'points-text': {	2✔
306	type: PointLabelLayer,	2✔
307	extensions: [collisionFilterExtension],	2✔
308	collisionEnabled: true,	2✔
309	collisionGroup,	2✔
310		2✔
311	// getPointRadius already has radiusScale baked in, so only pass one or the other	2✔
312	...(result.getPointRadius	2!
UNCOV 313	? {getRadius: result.getPointRadius}	×
314	: {radiusScale: visConfig.radius}),	2✔
315		2✔
316	...(secondaryField && {	2✔
317	getSecondaryText,	1✔
318	getSecondaryColor,	1✔
319	secondarySizeScale,	1✔
320	secondaryOutlineColor	1✔
321	})	1✔
322	}	2✔
323	};	2✔
324	}	2✔
325		16✔
326	return result;	16✔
327	}	16✔
328		1✔
329	function createLoadOptions(accessToken: string) {	16✔
330	return {	16✔
331	loadOptions: {fetch: {headers: {Authorization: `Bearer ${accessToken}`}}}	16✔
332	};	16✔
333	}	16✔

visgl / deck.gl / 8970341128

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