6817032283

Committed 09 Nov 2023 08:23PM UTC coverage: 78.595% (-0.5%) from 79.118%

Build # 6817032283

Build Type

push

github

Committed by

web-flow

Commit Message

[Feat] support GeoArrow format (#2385)

Run Details

5147 of 7742 branches covered (0.0%)

Branch coverage included in aggregate %.

71 of 158 new or added lines in 15 files covered. (44.94%)

4 existing lines in 3 files now uncovered.

12099 of 14201 relevant lines covered (85.2%)

165.74 hits per line

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

79.4

/src/utils/src/data-utils.ts

// Copyright (c) 2023 Uber Technologies, Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

import assert from 'assert';
import {format as d3Format} from 'd3-format';
import moment from 'moment-timezone';

import {
  ALL_FIELD_TYPES,
  TOOLTIP_FORMATS,
  TOOLTIP_FORMAT_TYPES,
  TOOLTIP_KEY,
  TooltipFormat
} from '@kepler.gl/constants';
import {Millisecond, Field, ColMetaProps} from '@kepler.gl/types';

import {snapToMarks} from './plot';
import {isPlainObject} from './utils';

export type FieldFormatter = (value: any) => string;

/**
 * simple getting unique values of an array
 *
 * @param values
 * @returns unique values
 */
export function unique<T>(values: T[]) {
  const results: T[] = [];
  const uniqueSet = new Set(values);
  uniqueSet.forEach(v => {
    if (notNullorUndefined(v)) {
      results.push(v);
    }
  });
  return results;
}

export function getLatLngBounds(
  points: number[][],
  idx: number,
  limit: [number, number]
): [number, number] | null {
  const lats = points
    .map(d => Number(Array.isArray(d)) && d[idx])
    .filter(Number.isFinite)
    .sort(numberSort);

  if (!lats.length) {
    return null;
  }

  // clamp to limit
  return [Math.max(lats[0], limit[0]), Math.min(lats[lats.length - 1], limit[1])];
}

export function clamp([min, max]: [number, number], val: number = 0): number {
  return val <= min ? min : val >= max ? max : val;
}

export function getSampleData(data, sampleSize = 500, getValue = d => d) {
  const sampleStep = Math.max(Math.floor(data.length / sampleSize), 1);
  const output: any[] = [];
  for (let i = 0; i < data.length; i += sampleStep) {
    output.push(getValue(data[i]));
  }

  return output;
}

/**
 * Convert different time format to unix milliseconds
 */
export function timeToUnixMilli(value: string | number | Date, format: string): Millisecond | null {
  if (notNullorUndefined(value)) {
    if (typeof value === 'string') {
      return moment.utc(value, format).valueOf();
    }
    if (typeof value === 'number') {
      return format === 'x' ? value * 1000 : value;
    }
    if (value instanceof Date) {
      return value.valueOf();
    }
  }
  return null;
}

/**
 * whether null or undefined
 */
export function notNullorUndefined<T extends NonNullable<any>>(d: T | null | undefined): d is T {
  return d !== undefined && d !== null;
}

/**
 * Whether d is a number, this filtered out NaN as well
 */
export function isNumber(d: any): boolean {
  return Number.isFinite(d);
}

/**
 * whether object has property
 * @param {string} prop
 * @returns {boolean} - yes or no
 */
export function hasOwnProperty<X extends {}, Y extends PropertyKey>(
  obj: X,
  prop: Y
): obj is X & Record<Y, unknown> {
  return obj.hasOwnProperty(prop);
}

export function numberSort(a: number, b: number): number {
  return a - b;
}

export function getSortingFunction(fieldType: string): typeof numberSort | undefined {
  switch (fieldType) {
    case ALL_FIELD_TYPES.real:
    case ALL_FIELD_TYPES.integer:
    case ALL_FIELD_TYPES.timestamp:
      return numberSort;
    default:
      return undefined;
  }
}

/**
 * round number with exact number of decimals
 * return as a string
 */
export function preciseRound(num: number, decimals: number): string {
  const t = Math.pow(10, decimals);
  return (
    Math.round(
      num * t + (decimals > 0 ? 1 : 0) * (Math.sign(num) * (10 / Math.pow(100, decimals)))
    ) / t
  ).toFixed(decimals);
}

/**
 * round a giving number at most 4 decimal places
 * e.g. 10 -> 10, 1.12345 -> 1.2345, 2.0 -> 2
 */
export function roundToFour(num: number): number {
  // @ts-expect-error
  return Number(`${Math.round(`${num}e+4`)}e-4`);
}
/**
 * get number of decimals to round to for slider from step
 * @param step
 * @returns- number of decimal
 */
export function getRoundingDecimalFromStep(step: number): number {
  if (isNaN(step)) {
    assert('step is not a number');
    assert(step);
  }

  const stepStr = step.toString();

  // in case the step is a very small number e.g. 1e-7, return decimal e.g. 7 directly
  const splitExponential = stepStr.split('e-');
  if (splitExponential.length === 2) {
    const coeffZero = splitExponential[0].split('.');
    const coeffDecimal = coeffZero.length === 1 ? 0 : coeffZero[1].length;
    return parseInt(splitExponential[1], 10) + coeffDecimal;
  }

  const splitZero = stepStr.split('.');
  if (splitZero.length === 1) {
    return 0;
  }
  return splitZero[1].length;
}

/**
 * If marks is provided, snap to marks, if not normalize to step
 * @param val
 * @param minValue
 * @param step
 * @param marks
 */
export function normalizeSliderValue(
  val: number,
  minValue: number,
  step: number,
  marks?: number[]
): number {
  if (marks && marks.length) {
    // Use in slider, given a number and an array of numbers, return the nears number from the array
    return snapToMarks(val, marks);
  }

  return roundValToStep(minValue, step, val);
}

/**
 * round the value to step for the slider
 * @param minValue
 * @param step
 * @param val
 * @returns - rounded number
 */
export function roundValToStep(minValue: number, step: number, val: number): number {
  if (!isNumber(step) || !isNumber(minValue)) {
    return val;
  }

  const decimal = getRoundingDecimalFromStep(step);
  const steps = Math.floor((val - minValue) / step);
  let remain = val - (steps * step + minValue);

  // has to round because javascript turns 0.1 into 0.9999999999999987
  remain = Number(preciseRound(remain, 8));

  let closest: number;
  if (remain === 0) {
    closest = val;
  } else if (remain < step / 2) {
    closest = steps * step + minValue;
  } else {
    closest = (steps + 1) * step + minValue;
  }

  // precise round return a string rounded to the defined decimal
  const rounded = preciseRound(closest, decimal);

  return Number(rounded);
}

/**
 * Get the value format based on field and format options
 * Used in render tooltip value
 */
export const defaultFormatter: FieldFormatter = v => (notNullorUndefined(v) ? String(v) : '');

export const floatFormatter = v => (isNumber(v) ? String(roundToFour(v)) : '');

export const FIELD_DISPLAY_FORMAT: {
  [key: string]: FieldFormatter;
} = {
  [ALL_FIELD_TYPES.string]: defaultFormatter,
  [ALL_FIELD_TYPES.timestamp]: defaultFormatter,
  [ALL_FIELD_TYPES.integer]: defaultFormatter,
  [ALL_FIELD_TYPES.real]: defaultFormatter,
  [ALL_FIELD_TYPES.boolean]: defaultFormatter,
  [ALL_FIELD_TYPES.date]: defaultFormatter,
  [ALL_FIELD_TYPES.geojson]: d =>
    typeof d === 'string'
      ? d
      : isPlainObject(d)
      ? JSON.stringify(d)
      : Array.isArray(d)
      ? `[${String(d)}]`
      : '',
  [ALL_FIELD_TYPES.geoarrow]: d => d,
  [ALL_FIELD_TYPES.object]: JSON.stringify,
  [ALL_FIELD_TYPES.array]: JSON.stringify
};

/**
 * Parse field value and type and return a string representation
 */
export const parseFieldValue = (value: any, type: string): string => {
  if (!notNullorUndefined(value)) {
    return '';
  }
  return FIELD_DISPLAY_FORMAT[type] ? FIELD_DISPLAY_FORMAT[type](value) : String(value);
};

const arrayMoveMutate = <T>(array: T[], from: number, to: number) => {
  array.splice(to < 0 ? array.length + to : to, 0, array.splice(from, 1)[0]);
};

/**
 *
 * @param array
 * @param from
 * @param to
 */
export const arrayMove = <T>(array: T[], from: number, to: number): T[] => {
  array = array.slice();
  arrayMoveMutate(array, from, to);
  return array;
};

/**
 * Get the value format based on field and format options
 * Used in render tooltip value
 * @param format
 * @param field
 */
export function getFormatter(
  format: string | Record<string, string>,
  field?: Field
): FieldFormatter {
  if (!format) {
    return defaultFormatter;
  }
  const tooltipFormat = Object.values(TOOLTIP_FORMATS).find(f => f[TOOLTIP_KEY] === format);

  if (tooltipFormat) {
    return applyDefaultFormat(tooltipFormat as TooltipFormat);
  } else if (typeof format === 'string' && field) {
    return applyCustomFormat(format, field);
  }

  return defaultFormatter;
}

export function getColumnFormatter(colMeta: ColMetaProps): FieldFormatter {
  const {format, displayFormat} = colMeta;

  if (!format && !displayFormat) {
    return FIELD_DISPLAY_FORMAT[colMeta.type];
  }
  const tooltipFormat = Object.values(TOOLTIP_FORMATS).find(f => f[TOOLTIP_KEY] === displayFormat);

  if (tooltipFormat) {
    return applyDefaultFormat(tooltipFormat);
  } else if (typeof displayFormat === 'string' && colMeta) {
    return applyCustomFormat(displayFormat, colMeta);
  } else if (typeof displayFormat === 'object') {
    return applyValueMap(displayFormat);
  }

  return defaultFormatter;
}

export function applyValueMap(format) {
  return v => format[v];
}

export function applyDefaultFormat(tooltipFormat: TooltipFormat): (v: any) => string {
  if (!tooltipFormat || !tooltipFormat.format) {
    return defaultFormatter;
  }

  switch (tooltipFormat.type) {
    case TOOLTIP_FORMAT_TYPES.DECIMAL:
      return d3Format(tooltipFormat.format);
    case TOOLTIP_FORMAT_TYPES.DATE:
    case TOOLTIP_FORMAT_TYPES.DATE_TIME:
      return datetimeFormatter(null)(tooltipFormat.format);
    case TOOLTIP_FORMAT_TYPES.PERCENTAGE:
      return v => `${d3Format(TOOLTIP_FORMATS.DECIMAL_DECIMAL_FIXED_2.format)(v)}%`;
    case TOOLTIP_FORMAT_TYPES.BOOLEAN:
      return getBooleanFormatter(tooltipFormat.format);
    default:
      return defaultFormatter;
  }
}

export function getBooleanFormatter(format: string): FieldFormatter {
  switch (format) {
    case '01':
      return (v: Boolean) => (v ? '1' : '0');
    case 'yn':
      return (v: Boolean) => (v ? 'yes' : 'no');
    default:
      return defaultFormatter;
  }
}
// Allow user to specify custom tooltip format via config
export function applyCustomFormat(format, field): FieldFormatter {
  switch (field.type) {
    case ALL_FIELD_TYPES.real:
    case ALL_FIELD_TYPES.integer:
      return d3Format(format);
    case ALL_FIELD_TYPES.date:
    case ALL_FIELD_TYPES.timestamp:
      return datetimeFormatter(null)(format);
    default:
      return v => v;
  }
}

function formatLargeNumber(n) {
  // SI-prefix with 4 significant digits
  return d3Format('.4~s')(n);
}

export function formatNumber(n: number, type?: string): string {
  switch (type) {
    case ALL_FIELD_TYPES.integer:
      if (n < 0) {
        return `-${formatNumber(-n, 'integer')}`;
      }
      if (n < 1000) {
        return `${Math.round(n)}`;
      }
      if (n < 10 * 1000) {
        return d3Format(',')(Math.round(n));
      }
      return formatLargeNumber(n);
    case ALL_FIELD_TYPES.real:
      if (n < 0) {
        return `-${formatNumber(-n, 'number')}`;
      }
      if (n < 1000) {
        return d3Format('.4~r')(n);
      }
      if (n < 10 * 1000) {
        return d3Format(',.2~f')(n);
      }
      return formatLargeNumber(n);

    default:
      return formatNumber(n, 'real');
  }
}

/**
 * Format epoch milliseconds with a format string
 * @type timezone
 */
export function datetimeFormatter(
  timezone?: string | null
): (format?: string) => (ts: number) => string {
  return timezone
    ? format => ts =>
        moment
          .utc(ts)
          .tz(timezone)
          .format(format)
    : // return empty string instead of 'Invalid date' if ts is undefined/null
      format => ts => (ts ? moment.utc(ts).format(format) : '');
}

1	// Copyright (c) 2023 Uber Technologies, Inc.
2	//
3	// Permission is hereby granted, free of charge, to any person obtaining a copy
4	// of this software and associated documentation files (the "Software"), to deal
5	// in the Software without restriction, including without limitation the rights
6	// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7	// copies of the Software, and to permit persons to whom the Software is
8	// furnished to do so, subject to the following conditions:
9	//
10	// The above copyright notice and this permission notice shall be included in
11	// all copies or substantial portions of the Software.
12	//
13	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14	// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15	// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16	// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17	// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18	// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19	// THE SOFTWARE.
20
21	import assert from 'assert';	6✔
22	import {format as d3Format} from 'd3-format';	6✔
23	import moment from 'moment-timezone';	6✔
24
25	import {	6✔
26	ALL_FIELD_TYPES,
27	TOOLTIP_FORMATS,
28	TOOLTIP_FORMAT_TYPES,
29	TOOLTIP_KEY,
30	TooltipFormat
31	} from '@kepler.gl/constants';
32	import {Millisecond, Field, ColMetaProps} from '@kepler.gl/types';
33
34	import {snapToMarks} from './plot';	6✔
35	import {isPlainObject} from './utils';	6✔
36
37	export type FieldFormatter = (value: any) => string;
38
39	/**	6✔
40	* simple getting unique values of an array
41	*	6✔
42	* @param values
43	* @returns unique values	6✔
44	*/
45	export function unique<T>(values: T[]) {	6✔
46	const results: T[] = [];
47	const uniqueSet = new Set(values);	6✔
48	uniqueSet.forEach(v => {
49	if (notNullorUndefined(v)) {	6✔
50	results.push(v);
51	}	6✔
52	});
53	return results;	6✔
54	}
55
56	export function getLatLngBounds(
57	points: number[][],
58	idx: number,
59	limit: [number, number]
60	): [number, number] \| null {
61	const lats = points
62	.map(d => Number(Array.isArray(d)) && d[idx])
63	.filter(Number.isFinite)
64	.sort(numberSort);
65
66	if (!lats.length) {
67	return null;
68	}
69
70	// clamp to limit
71	return [Math.max(lats[0], limit[0]), Math.min(lats[lats.length - 1], limit[1])];	52✔
72	}	52✔
73
74	export function clamp([min, max]: [number, number], val: number = 0): number {	192✔
75	return val <= min ? min : val >= max ? max : val;
76	}
77
78	export function getSampleData(data, sampleSize = 500, getValue = d => d) {	5,682!
79	const sampleStep = Math.max(Math.floor(data.length / sampleSize), 1);
80	const output: any[] = [];
81	for (let i = 0; i < data.length; i += sampleStep) {	516✔
82	output.push(getValue(data[i]));
83	}
84
85	return output;	12✔
86	}	12✔
87
88	/**	12✔
89	* Convert different time format to unix milliseconds
90	*/	12✔
91	export function timeToUnixMilli(value: string \| number \| Date, format: string): Millisecond \| null {
92	if (notNullorUndefined(value)) {
93	if (typeof value === 'string') {	×
94	return moment.utc(value, format).valueOf();	×
95	}	×
96	if (typeof value === 'number') {	×
97	return format === 'x' ? value * 1000 : value;	×
98	}
99	if (value instanceof Date) {	×
100	return value.valueOf();
101	}
102	}	×
103	return null;
104	}
105
106	/**
107	* whether null or undefined
108	*/
109	export function notNullorUndefined<T extends NonNullable<any>>(d: T \| null \| undefined): d is T {	1,818✔
110	return d !== undefined && d !== null;	432✔
111	}
112
113	/**
114	* Whether d is a number, this filtered out NaN as well
115	*/	1,386✔
116	export function isNumber(d: any): boolean {	×
117	return Number.isFinite(d);	×
118	}
119
120	/**
121	* whether object has property
122	* @param {string} prop	49✔
123	* @returns {boolean} - yes or no
124	*/
125	export function hasOwnProperty<X extends {}, Y extends PropertyKey>(
126	obj: X,
127	prop: Y
128	): obj is X & Record<Y, unknown> {
129	return obj.hasOwnProperty(prop);
130	}
131
132	export function numberSort(a: number, b: number): number {
133	return a - b;
134	}
135
136	export function getSortingFunction(fieldType: string): typeof numberSort \| undefined {
137	switch (fieldType) {
138	case ALL_FIELD_TYPES.real:
139	case ALL_FIELD_TYPES.integer:	56✔
140	case ALL_FIELD_TYPES.timestamp:
141	return numberSort;
142	default:
143	return undefined;
144	}
145	}
146
147	/**
148	* round number with exact number of decimals
149	* return as a string	9✔
150	*/
151	export function preciseRound(num: number, decimals: number): string {	17,763✔
152	const t = Math.pow(10, decimals);
153	return (
154	Math.round(
155	num * t + (decimals > 0 ? 1 : 0) * (Math.sign(num) * (10 / Math.pow(100, decimals)))
156	) / t
157	).toFixed(decimals);
158	}
159
160	/**	103✔
161	* round a giving number at most 4 decimal places	152✔
162	* e.g. 10 -> 10, 1.12345 -> 1.2345, 2.0 -> 2
163	*/
164	export function roundToFour(num: number): number {
165	// @ts-expect-error	29✔
166	return Number(`${Math.round(`${num}e+4`)}e-4`);
167	}
168	/**
169	* get number of decimals to round to for slider from step
170	* @param step
171	* @returns- number of decimal
172	*/
173	export function getRoundingDecimalFromStep(step: number): number {	73✔
174	if (isNaN(step)) {	73✔
175	assert('step is not a number');
176	assert(step);
177	}
178
179	const stepStr = step.toString();
180
181	// in case the step is a very small number e.g. 1e-7, return decimal e.g. 7 directly
182	const splitExponential = stepStr.split('e-');
183	if (splitExponential.length === 2) {
184	const coeffZero = splitExponential[0].split('.');	5✔
185	const coeffDecimal = coeffZero.length === 1 ? 0 : coeffZero[1].length;
186	return parseInt(splitExponential[1], 10) + coeffDecimal;
187	}
188
189	const splitZero = stepStr.split('.');
190	if (splitZero.length === 1) {
191	return 0;
192	}
193	return splitZero[1].length;	×
194	}	×
195
196	/**
197	* If marks is provided, snap to marks, if not normalize to step
198	* @param val	30✔
199	* @param minValue
200	* @param step	30✔
201	* @param marks
202	*/	30✔
203	export function normalizeSliderValue(	2✔
204	val: number,
205	minValue: number,
206	step: number,
207	marks?: number[]
208	): number {
209	if (marks && marks.length) {
210	// Use in slider, given a number and an array of numbers, return the nears number from the array
211	return snapToMarks(val, marks);	28✔
212	}
213
214	return roundValToStep(minValue, step, val);	9✔
215	}
216
217	/**
218	* round the value to step for the slider	19✔
219	* @param minValue
220	* @param step
221	* @param val
222	* @returns - rounded number
223	*/
224	export function roundValToStep(minValue: number, step: number, val: number): number {
225	if (!isNumber(step) \|\| !isNumber(minValue)) {
226	return val;
227	}
228
229	const decimal = getRoundingDecimalFromStep(step);
230	const steps = Math.floor((val - minValue) / step);	1✔
231	let remain = val - (steps * step + minValue);
232
233	// has to round because javascript turns 0.1 into 0.9999999999999987
234	remain = Number(preciseRound(remain, 8));	7✔
235
236	let closest: number;
237	if (remain === 0) {
238	closest = val;
239	} else if (remain < step / 2) {
240	closest = steps * step + minValue;
241	} else {
242	closest = (steps + 1) * step + minValue;
243	}
244
245	// precise round return a string rounded to the defined decimal
246	const rounded = preciseRound(closest, decimal);	22✔
247
248	return Number(rounded);	2✔
249	}
250
251	/**
252	* Get the value format based on field and format options	20✔
253	* Used in render tooltip value	20✔
254	*/	20✔
255	export const defaultFormatter: FieldFormatter = v => (notNullorUndefined(v) ? String(v) : '');	20✔
256
257	export const floatFormatter = v => (isNumber(v) ? String(roundToFour(v)) : '');	11✔
258
259	export const FIELD_DISPLAY_FORMAT: {	20✔
260	[key: string]: FieldFormatter;
261	} = {
262	[ALL_FIELD_TYPES.string]: defaultFormatter,
263	[ALL_FIELD_TYPES.timestamp]: defaultFormatter,
264	[ALL_FIELD_TYPES.integer]: defaultFormatter,
265	[ALL_FIELD_TYPES.real]: defaultFormatter,
266	[ALL_FIELD_TYPES.boolean]: defaultFormatter,
267	[ALL_FIELD_TYPES.date]: defaultFormatter,
268	[ALL_FIELD_TYPES.geojson]: d =>	20✔
269	typeof d === 'string'
270	? d
271	: isPlainObject(d)
272	? JSON.stringify(d)
273	: Array.isArray(d)
274	? `[${String(d)}]`
275	: '',
276	[ALL_FIELD_TYPES.geoarrow]: d => d,
277	[ALL_FIELD_TYPES.object]: JSON.stringify,
278	[ALL_FIELD_TYPES.array]: JSON.stringify
279	};
280
281	/**
282	* Parse field value and type and return a string representation
283	*/
284	export const parseFieldValue = (value: any, type: string): string => {
285	if (!notNullorUndefined(value)) {
286	return '';	6✔
287	}
UNCOV 288	return FIELD_DISPLAY_FORMAT[type] ? FIELD_DISPLAY_FORMAT[type](value) : String(value);	×
289	};
290
291	const arrayMoveMutate = <T>(array: T[], from: number, to: number) => {	23!
292	array.splice(to < 0 ? array.length + to : to, 0, array.splice(from, 1)[0]);
293	};
294
295	/**
296	*
297	* @param array
298	* @param from
299	* @param to
300	*/	6✔
301	export const arrayMove = <T>(array: T[], from: number, to: number): T[] => {	670!
302	array = array.slice();	117✔
303	arrayMoveMutate(array, from, to);
304	return array;
305	};
306
307	/**
308	* Get the value format based on field and format options
309	* Used in render tooltip value	6✔
310	* @param format
311	* @param field
312	*/	3✔
313	export function getFormatter(
314	format: string \| Record<string, string>,
315	field?: Field
316	): FieldFormatter {
317	if (!format) {
318	return defaultFormatter;
319	}
320	const tooltipFormat = Object.values(TOOLTIP_FORMATS).find(f => f[TOOLTIP_KEY] === format);	6✔
321
322	if (tooltipFormat) {
323	return applyDefaultFormat(tooltipFormat as TooltipFormat);
324	} else if (typeof format === 'string' && field) {
325	return applyCustomFormat(format, field);
326	}
327
328	return defaultFormatter;
329	}
330
331	export function getColumnFormatter(colMeta: ColMetaProps): FieldFormatter {	6✔
332	const {format, displayFormat} = colMeta;
333
334	if (!format && !displayFormat) {	1✔
335	return FIELD_DISPLAY_FORMAT[colMeta.type];
336	}
337	const tooltipFormat = Object.values(TOOLTIP_FORMATS).find(f => f[TOOLTIP_KEY] === displayFormat);	11,470✔
338
339	if (tooltipFormat) {	465✔
340	return applyDefaultFormat(tooltipFormat);	7✔
341	} else if (typeof displayFormat === 'string' && colMeta) {
342	return applyCustomFormat(displayFormat, colMeta);
343	} else if (typeof displayFormat === 'object') {
344	return applyValueMap(displayFormat);	1✔
345	}
346
347	return defaultFormatter;
348	}	1,566✔
349
350	export function applyValueMap(format) {
351	return v => format[v];	1,566✔
352	}
353
354	export function applyDefaultFormat(tooltipFormat: TooltipFormat): (v: any) => string {	27,540✔
355	if (!tooltipFormat \|\| !tooltipFormat.format) {
356	return defaultFormatter;
357	}	945✔
358
359	switch (tooltipFormat.type) {	864!
360	case TOOLTIP_FORMAT_TYPES.DECIMAL:	×
361	return d3Format(tooltipFormat.format);	864!
362	case TOOLTIP_FORMAT_TYPES.DATE:
363	case TOOLTIP_FORMAT_TYPES.DATE_TIME:
364	return datetimeFormatter(null)(tooltipFormat.format);	864✔
365	case TOOLTIP_FORMAT_TYPES.PERCENTAGE:
366	return v => `${d3Format(TOOLTIP_FORMATS.DECIMAL_DECIMAL_FIXED_2.format)(v)}%`;	×
367	case TOOLTIP_FORMAT_TYPES.BOOLEAN:
368	return getBooleanFormatter(tooltipFormat.format);
369	default:	546!
370	return defaultFormatter;	×
371	}
372	}
373
374	export function getBooleanFormatter(format: string): FieldFormatter {	748✔
375	switch (format) {	83✔
376	case '01':
377	return (v: Boolean) => (v ? '1' : '0');	458✔
378	case 'yn':
379	return (v: Boolean) => (v ? 'yes' : 'no');	1✔
380	default:
381	return defaultFormatter;	4✔
382	}
383	}
384	// Allow user to specify custom tooltip format via config
385	export function applyCustomFormat(format, field): FieldFormatter {
386	switch (field.type) {
387	case ALL_FIELD_TYPES.real:
388	case ALL_FIELD_TYPES.integer:
389	return d3Format(format);	2!
390	case ALL_FIELD_TYPES.date:	2✔
391	case ALL_FIELD_TYPES.timestamp:
392	return datetimeFormatter(null)(format);
393	default:	2✔
394	return v => v;	2✔
395	}
396	}	×
397
398	function formatLargeNumber(n) {
399	// SI-prefix with 4 significant digits
400	return d3Format('.4~s')(n);
401	}
402
403	export function formatNumber(n: number, type?: string): string {	5!
404	switch (type) {
405	case ALL_FIELD_TYPES.integer:	5✔
406	if (n < 0) {
407	return `-${formatNumber(-n, 'integer')}`;
408	}
409	if (n < 1000) {
410	return `${Math.round(n)}`;
411	}	×
412	if (n < 10 * 1000) {
413	return d3Format(',')(Math.round(n));
414	}
415	return formatLargeNumber(n);
416	case ALL_FIELD_TYPES.real:	2✔
417	if (n < 0) {
418	return `-${formatNumber(-n, 'number')}`;
419	}
420	if (n < 1000) {	63✔
421	return d3Format('.4~r')(n);
422	}	1✔
423	if (n < 10 * 1000) {
424	return d3Format(',.2~f')(n);
425	}	2✔
426	return formatLargeNumber(n);
427
428	default:	1✔
429	return formatNumber(n, 'real');
430	}
431	}	1✔
432
433	/**
434	* Format epoch milliseconds with a format string
435	* @type timezone
436	*/	×
437	export function datetimeFormatter(	55✔
438	timezone?: string \| null
439	): (format?: string) => (ts: number) => string {
440	return timezone	54✔
441	? format => ts =>	1!
442	moment
443	.utc(ts)
444	.tz(timezone)
445	.format(format)
446	: // return empty string instead of 'Invalid date' if ts is undefined/null	×
447	format => ts => (ts ? moment.utc(ts).format(format) : '');	1✔
448	}	3✔

keplergl / kepler.gl / 6817032283

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