@kepler.gl/utils 3.1.0-alpha.1 → 3.1.0-alpha.2

package/dist/data-utils.js

@@ -0,0 +1,436 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FIELD_DISPLAY_FORMAT = void 0;
+exports.applyCustomFormat = applyCustomFormat;
+exports.applyDefaultFormat = applyDefaultFormat;
+exports.applyValueMap = applyValueMap;
+exports.clamp = clamp;
+exports.datetimeFormatter = datetimeFormatter;
+exports.floatFormatter = exports.defaultFormatter = void 0;
+exports.formatNumber = formatNumber;
+exports.getBooleanFormatter = getBooleanFormatter;
+exports.getColumnFormatter = getColumnFormatter;
+exports.getFormatter = getFormatter;
+exports.getLatLngBounds = getLatLngBounds;
+exports.getRoundingDecimalFromStep = getRoundingDecimalFromStep;
+exports.getSampleData = getSampleData;
+exports.getSortingFunction = getSortingFunction;
+exports.hasOwnProperty = hasOwnProperty;
+exports.isNumber = isNumber;
+exports.normalizeSliderValue = normalizeSliderValue;
+exports.numberSort = numberSort;
+exports.parseFieldValue = void 0;
+exports.preciseRound = preciseRound;
+exports.reverseFormatNumber = reverseFormatNumber;
+exports.roundToFour = roundToFour;
+exports.roundValToStep = roundValToStep;
+exports.timeToUnixMilli = timeToUnixMilli;
+exports.unique = unique;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _assert = _interopRequireDefault(require("assert"));
+var _d3Format = require("d3-format");
+var _momentTimezone = _interopRequireDefault(require("moment-timezone"));
+var _constants = require("@kepler.gl/constants");
+var _commonUtils = require("@kepler.gl/common-utils");
+var _plot = require("./plot");
+var _utils = require("./utils");
+var _FIELD_DISPLAY_FORMAT; // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+/**
+ * simple getting unique values of an array
+ *
+ * @param values
+ * @returns unique values
+ */
+function unique(values) {
+  var results = [];
+  var uniqueSet = new Set(values);
+  uniqueSet.forEach(function (v) {
+    if ((0, _commonUtils.notNullorUndefined)(v)) {
+      results.push(v);
+    }
+  });
+  return results;
+}
+function getLatLngBounds(points, idx, limit) {
+  var lats = points.map(function (d) {
+    return 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])];
+}
+function clamp(_ref) {
+  var _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
+    min = _ref2[0],
+    max = _ref2[1];
+  var val = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  return val <= min ? min : val >= max ? max : val;
+}
+function getSampleData(data) {
+  var sampleSize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 500;
+  var getValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function (d) {
+    return d;
+  };
+  var sampleStep = Math.max(Math.floor(data.length / sampleSize), 1);
+  var output = [];
+  for (var i = 0; i < data.length; i += sampleStep) {
+    output.push(getValue(data[i]));
+  }
+  return output;
+}
+
+/**
+ * Convert different time format to unix milliseconds
+ */
+function timeToUnixMilli(value, format) {
+  if ((0, _commonUtils.notNullorUndefined)(value)) {
+    if (typeof value === 'string') {
+      return _momentTimezone["default"].utc(value, format).valueOf();
+    }
+    if (typeof value === 'number') {
+      return format === 'x' ? value * 1000 : value;
+    }
+    if (value instanceof Date) {
+      return value.valueOf();
+    }
+  }
+  return null;
+}
+
+/**
+ * Whether d is a number, this filtered out NaN as well
+ */
+function isNumber(d) {
+  return Number.isFinite(d);
+}
+
+/**
+ * whether object has property
+ * @param {string} prop
+ * @returns {boolean} - yes or no
+ */
+function hasOwnProperty(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+function numberSort(a, b) {
+  return a - b;
+}
+function getSortingFunction(fieldType) {
+  switch (fieldType) {
+    case _constants.ALL_FIELD_TYPES.real:
+    case _constants.ALL_FIELD_TYPES.integer:
+    case _constants.ALL_FIELD_TYPES.timestamp:
+      return numberSort;
+    default:
+      return undefined;
+  }
+}
+
+/**
+ * round number with exact number of decimals
+ * return as a string
+ */
+function preciseRound(num, decimals) {
+  var 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
+ */
+function roundToFour(num) {
+  // @ts-expect-error
+  return Number("".concat(Math.round("".concat(num, "e+4")), "e-4"));
+}
+/**
+ * get number of decimals to round to for slider from step
+ * @param step
+ * @returns- number of decimal
+ */
+function getRoundingDecimalFromStep(step) {
+  if (isNaN(step)) {
+    (0, _assert["default"])('step is not a number');
+    (0, _assert["default"])(step);
+  }
+  var stepStr = step.toString();
+
+  // in case the step is a very small number e.g. 1e-7, return decimal e.g. 7 directly
+  var splitExponential = stepStr.split('e-');
+  if (splitExponential.length === 2) {
+    var coeffZero = splitExponential[0].split('.');
+    var coeffDecimal = coeffZero.length === 1 ? 0 : coeffZero[1].length;
+    return parseInt(splitExponential[1], 10) + coeffDecimal;
+  }
+  var 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
+ */
+function normalizeSliderValue(val, minValue, step, marks) {
+  if (marks && marks.length) {
+    // Use in slider, given a number and an array of numbers, return the nears number from the array
+    return (0, _plot.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
+ */
+function roundValToStep(minValue, step, val) {
+  if (!isNumber(step) || !isNumber(minValue)) {
+    return val;
+  }
+  var decimal = getRoundingDecimalFromStep(step);
+  var steps = Math.floor((val - minValue) / step);
+  var remain = val - (steps * step + minValue);
+
+  // has to round because javascript turns 0.1 into 0.9999999999999987
+  remain = Number(preciseRound(remain, 8));
+  var closest;
+  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
+  var rounded = preciseRound(closest, decimal);
+  return Number(rounded);
+}
+
+/**
+ * Get the value format based on field and format options
+ * Used in render tooltip value
+ */
+var defaultFormatter = exports.defaultFormatter = function defaultFormatter(v) {
+  return (0, _commonUtils.notNullorUndefined)(v) ? String(v) : '';
+};
+var floatFormatter = exports.floatFormatter = function floatFormatter(v) {
+  return isNumber(v) ? String(roundToFour(v)) : '';
+};
+var FIELD_DISPLAY_FORMAT = exports.FIELD_DISPLAY_FORMAT = (_FIELD_DISPLAY_FORMAT = {}, (0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])(_FIELD_DISPLAY_FORMAT, _constants.ALL_FIELD_TYPES.string, defaultFormatter), _constants.ALL_FIELD_TYPES.timestamp, defaultFormatter), _constants.ALL_FIELD_TYPES.integer, defaultFormatter), _constants.ALL_FIELD_TYPES.real, defaultFormatter), _constants.ALL_FIELD_TYPES["boolean"], defaultFormatter), _constants.ALL_FIELD_TYPES.date, defaultFormatter), _constants.ALL_FIELD_TYPES.geojson, function (d) {
+  return typeof d === 'string' ? d : (0, _utils.isPlainObject)(d) ? JSON.stringify(d) : Array.isArray(d) ? "[".concat(String(d), "]") : '';
+}), _constants.ALL_FIELD_TYPES.geoarrow, function (d) {
+  return d;
+}), _constants.ALL_FIELD_TYPES.object, JSON.stringify), _constants.ALL_FIELD_TYPES.array, JSON.stringify), (0, _defineProperty2["default"])(_FIELD_DISPLAY_FORMAT, _constants.ALL_FIELD_TYPES.h3, defaultFormatter));
+
+/**
+ * Parse field value and type and return a string representation
+ */
+var parseFieldValue = exports.parseFieldValue = function parseFieldValue(value, type) {
+  if (!(0, _commonUtils.notNullorUndefined)(value)) {
+    return '';
+  }
+  return FIELD_DISPLAY_FORMAT[type] ? FIELD_DISPLAY_FORMAT[type](value) : String(value);
+};
+
+/**
+ * Get the value format based on field and format options
+ * Used in render tooltip value
+ * @param format
+ * @param field
+ */
+function getFormatter(format, field) {
+  if (!format) {
+    return defaultFormatter;
+  }
+  var tooltipFormat = Object.values(_constants.TOOLTIP_FORMATS).find(function (f) {
+    return f[_constants.TOOLTIP_KEY] === format;
+  });
+  if (tooltipFormat) {
+    return applyDefaultFormat(tooltipFormat);
+  } else if (typeof format === 'string' && field) {
+    return applyCustomFormat(format, field);
+  }
+  return defaultFormatter;
+}
+function getColumnFormatter(field) {
+  var format = field.format,
+    displayFormat = field.displayFormat;
+  if (!format && !displayFormat) {
+    return FIELD_DISPLAY_FORMAT[field.type];
+  }
+  var tooltipFormat = Object.values(_constants.TOOLTIP_FORMATS).find(function (f) {
+    return f[_constants.TOOLTIP_KEY] === displayFormat;
+  });
+  if (tooltipFormat) {
+    return applyDefaultFormat(tooltipFormat);
+  } else if (typeof displayFormat === 'string' && field) {
+    return applyCustomFormat(displayFormat, field);
+  } else if ((0, _typeof2["default"])(displayFormat) === 'object') {
+    return applyValueMap(displayFormat);
+  }
+  return defaultFormatter;
+}
+function applyValueMap(format) {
+  return function (v) {
+    return format[v];
+  };
+}
+function applyDefaultFormat(tooltipFormat) {
+  if (!tooltipFormat || !tooltipFormat.format) {
+    return defaultFormatter;
+  }
+  switch (tooltipFormat.type) {
+    case _constants.TOOLTIP_FORMAT_TYPES.DECIMAL:
+      return (0, _d3Format.format)(tooltipFormat.format);
+    case _constants.TOOLTIP_FORMAT_TYPES.DATE:
+    case _constants.TOOLTIP_FORMAT_TYPES.DATE_TIME:
+      return datetimeFormatter(null)(tooltipFormat.format);
+    case _constants.TOOLTIP_FORMAT_TYPES.PERCENTAGE:
+      return function (v) {
+        return "".concat((0, _d3Format.format)(_constants.TOOLTIP_FORMATS.DECIMAL_DECIMAL_FIXED_2.format)(v), "%");
+      };
+    case _constants.TOOLTIP_FORMAT_TYPES.BOOLEAN:
+      return getBooleanFormatter(tooltipFormat.format);
+    default:
+      return defaultFormatter;
+  }
+}
+function getBooleanFormatter(format) {
+  switch (format) {
+    case '01':
+      return function (v) {
+        return v ? '1' : '0';
+      };
+    case 'yn':
+      return function (v) {
+        return v ? 'yes' : 'no';
+      };
+    default:
+      return defaultFormatter;
+  }
+}
+// Allow user to specify custom tooltip format via config
+function applyCustomFormat(format, field) {
+  switch (field.type) {
+    case _constants.ALL_FIELD_TYPES.real:
+    case _constants.ALL_FIELD_TYPES.integer:
+      return (0, _d3Format.format)(format);
+    case _constants.ALL_FIELD_TYPES.date:
+    case _constants.ALL_FIELD_TYPES.timestamp:
+      return datetimeFormatter(null)(format);
+    default:
+      return function (v) {
+        return v;
+      };
+  }
+}
+function formatLargeNumber(n) {
+  // SI-prefix with 4 significant digits
+  return (0, _d3Format.format)('.4~s')(n);
+}
+function formatNumber(n, type) {
+  switch (type) {
+    case _constants.ALL_FIELD_TYPES.integer:
+      if (n < 0) {
+        return "-".concat(formatNumber(-n, 'integer'));
+      }
+      if (n < 1000) {
+        return "".concat(Math.round(n));
+      }
+      if (n < 10 * 1000) {
+        return (0, _d3Format.format)(',')(Math.round(n));
+      }
+      return formatLargeNumber(n);
+    case _constants.ALL_FIELD_TYPES.real:
+      if (n < 0) {
+        return "-".concat(formatNumber(-n, 'number'));
+      }
+      if (n < 1000) {
+        return (0, _d3Format.format)('.4~r')(n);
+      }
+      if (n < 10 * 1000) {
+        return (0, _d3Format.format)(',.2~f')(n);
+      }
+      return formatLargeNumber(n);
+    default:
+      return formatNumber(n, 'real');
+  }
+}
+var transformation = {
+  Y: Math.pow(10, 24),
+  Z: Math.pow(10, 21),
+  E: Math.pow(10, 18),
+  P: Math.pow(10, 15),
+  T: Math.pow(10, 12),
+  G: Math.pow(10, 9),
+  M: Math.pow(10, 6),
+  k: Math.pow(10, 3),
+  h: Math.pow(10, 2),
+  da: Math.pow(10, 1),
+  d: Math.pow(10, -1),
+  c: Math.pow(10, -2),
+  m: Math.pow(10, -3),
+  μ: Math.pow(10, -6),
+  n: Math.pow(10, -9),
+  p: Math.pow(10, -12),
+  f: Math.pow(10, -15),
+  a: Math.pow(10, -18),
+  z: Math.pow(10, -21),
+  y: Math.pow(10, -24)
+};
+
+/**
+ * Convert a formatted number from string back to number
+ */
+function reverseFormatNumber(str) {
+  var returnValue = null;
+  var strNum = str.trim().replace(/,/g, '');
+  Object.entries(transformation).forEach(function (d) {
+    if (strNum.includes(d[0])) {
+      returnValue = parseFloat(strNum) * d[1];
+      return true;
+    }
+    return false;
+  });
+
+  // if no transformer found, convert to nuber regardless
+  return returnValue === null ? Number(strNum) : returnValue;
+}
+
+/**
+ * Format epoch milliseconds with a format string
+ * @type timezone
+ */
+function datetimeFormatter(timezone) {
+  return timezone ? function (format) {
+    return function (ts) {
+      return _momentTimezone["default"].utc(ts).tz(timezone).format(format);
+    };
+  } :
+  // return empty string instead of 'Invalid date' if ts is undefined/null
+  function (format) {
+    return function (ts) {
+      return ts ? _momentTimezone["default"].utc(ts).format(format) : '';
+    };
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_assert","_interopRequireDefault","require","_d3Format","_momentTimezone","_constants","_commonUtils","_plot","_utils","_FIELD_DISPLAY_FORMAT","unique","values","results","uniqueSet","Set","forEach","v","notNullorUndefined","push","getLatLngBounds","points","idx","limit","lats","map","d","Number","Array","isArray","filter","isFinite","sort","numberSort","length","Math","max","min","clamp","_ref","_ref2","_slicedToArray2","val","arguments","undefined","getSampleData","data","sampleSize","getValue","sampleStep","floor","output","i","timeToUnixMilli","value","format","moment","utc","valueOf","Date","isNumber","hasOwnProperty","obj","prop","Object","prototype","call","a","b","getSortingFunction","fieldType","ALL_FIELD_TYPES","real","integer","timestamp","preciseRound","num","decimals","t","pow","round","sign","toFixed","roundToFour","concat","getRoundingDecimalFromStep","step","isNaN","assert","stepStr","toString","splitExponential","split","coeffZero","coeffDecimal","parseInt","splitZero","normalizeSliderValue","minValue","marks","snapToMarks","roundValToStep","decimal","steps","remain","closest","rounded","defaultFormatter","exports","String","floatFormatter","FIELD_DISPLAY_FORMAT","_defineProperty2","string","date","geojson","isPlainObject","JSON","stringify","geoarrow","object","array","h3","parseFieldValue","type","getFormatter","field","tooltipFormat","TOOLTIP_FORMATS","find","f","TOOLTIP_KEY","applyDefaultFormat","applyCustomFormat","getColumnFormatter","displayFormat","_typeof2","applyValueMap","TOOLTIP_FORMAT_TYPES","DECIMAL","d3Format","DATE","DATE_TIME","datetimeFormatter","PERCENTAGE","DECIMAL_DECIMAL_FIXED_2","BOOLEAN","getBooleanFormatter","formatLargeNumber","n","formatNumber","transformation","Y","Z","E","P","T","G","M","k","h","da","c","m","μ","p","z","y","reverseFormatNumber","str","returnValue","strNum","trim","replace","entries","includes","parseFloat","timezone","ts","tz"],"sources":["../src/data-utils.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport assert from 'assert';\nimport {format as d3Format} from 'd3-format';\nimport moment from 'moment-timezone';\n\nimport {\n  ALL_FIELD_TYPES,\n  TOOLTIP_FORMATS,\n  TOOLTIP_FORMAT_TYPES,\n  TOOLTIP_KEY,\n  TooltipFormat\n} from '@kepler.gl/constants';\nimport {notNullorUndefined} from '@kepler.gl/common-utils';\nimport {Field, Millisecond} from '@kepler.gl/types';\n\nimport {snapToMarks} from './plot';\nimport {isPlainObject} from './utils';\n\nexport type FieldFormatter = (value: any) => string;\n\n/**\n * simple getting unique values of an array\n *\n * @param values\n * @returns unique values\n */\nexport function unique<T>(values: T[]) {\n  const results: T[] = [];\n  const uniqueSet = new Set(values);\n  uniqueSet.forEach(v => {\n    if (notNullorUndefined(v)) {\n      results.push(v);\n    }\n  });\n  return results;\n}\n\nexport function getLatLngBounds(\n  points: number[][],\n  idx: number,\n  limit: [number, number]\n): [number, number] | null {\n  const lats = points\n    .map(d => Number(Array.isArray(d)) && d[idx])\n    .filter(Number.isFinite)\n    .sort(numberSort);\n\n  if (!lats.length) {\n    return null;\n  }\n\n  // clamp to limit\n  return [Math.max(lats[0], limit[0]), Math.min(lats[lats.length - 1], limit[1])];\n}\n\nexport function clamp([min, max]: [number, number], val = 0): number {\n  return val <= min ? min : val >= max ? max : val;\n}\n\nexport function getSampleData(data, sampleSize = 500, getValue = d => d) {\n  const sampleStep = Math.max(Math.floor(data.length / sampleSize), 1);\n  const output: any[] = [];\n  for (let i = 0; i < data.length; i += sampleStep) {\n    output.push(getValue(data[i]));\n  }\n\n  return output;\n}\n\n/**\n * Convert different time format to unix milliseconds\n */\nexport function timeToUnixMilli(value: string | number | Date, format: string): Millisecond | null {\n  if (notNullorUndefined(value)) {\n    if (typeof value === 'string') {\n      return moment.utc(value, format).valueOf();\n    }\n    if (typeof value === 'number') {\n      return format === 'x' ? value * 1000 : value;\n    }\n    if (value instanceof Date) {\n      return value.valueOf();\n    }\n  }\n  return null;\n}\n\n/**\n * Whether d is a number, this filtered out NaN as well\n */\nexport function isNumber(d: unknown): d is number {\n  return Number.isFinite(d);\n}\n\n/**\n * whether object has property\n * @param {string} prop\n * @returns {boolean} - yes or no\n */\nexport function hasOwnProperty<X extends object, Y extends PropertyKey>(\n  obj: X,\n  prop: Y\n): obj is X & Record<Y, unknown> {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nexport function numberSort(a: number, b: number): number {\n  return a - b;\n}\n\nexport function getSortingFunction(fieldType: string): typeof numberSort | undefined {\n  switch (fieldType) {\n    case ALL_FIELD_TYPES.real:\n    case ALL_FIELD_TYPES.integer:\n    case ALL_FIELD_TYPES.timestamp:\n      return numberSort;\n    default:\n      return undefined;\n  }\n}\n\n/**\n * round number with exact number of decimals\n * return as a string\n */\nexport function preciseRound(num: number, decimals: number): string {\n  const t = Math.pow(10, decimals);\n  return (\n    Math.round(\n      num * t + (decimals > 0 ? 1 : 0) * (Math.sign(num) * (10 / Math.pow(100, decimals)))\n    ) / t\n  ).toFixed(decimals);\n}\n\n/**\n * round a giving number at most 4 decimal places\n * e.g. 10 -> 10, 1.12345 -> 1.2345, 2.0 -> 2\n */\nexport function roundToFour(num: number): number {\n  // @ts-expect-error\n  return Number(`${Math.round(`${num}e+4`)}e-4`);\n}\n/**\n * get number of decimals to round to for slider from step\n * @param step\n * @returns- number of decimal\n */\nexport function getRoundingDecimalFromStep(step: number): number {\n  if (isNaN(step)) {\n    assert('step is not a number');\n    assert(step);\n  }\n\n  const stepStr = step.toString();\n\n  // in case the step is a very small number e.g. 1e-7, return decimal e.g. 7 directly\n  const splitExponential = stepStr.split('e-');\n  if (splitExponential.length === 2) {\n    const coeffZero = splitExponential[0].split('.');\n    const coeffDecimal = coeffZero.length === 1 ? 0 : coeffZero[1].length;\n    return parseInt(splitExponential[1], 10) + coeffDecimal;\n  }\n\n  const splitZero = stepStr.split('.');\n  if (splitZero.length === 1) {\n    return 0;\n  }\n  return splitZero[1].length;\n}\n\n/**\n * If marks is provided, snap to marks, if not normalize to step\n * @param val\n * @param minValue\n * @param step\n * @param marks\n */\nexport function normalizeSliderValue(\n  val: number,\n  minValue: number,\n  step: number,\n  marks?: number[] | null\n): number {\n  if (marks && marks.length) {\n    // Use in slider, given a number and an array of numbers, return the nears number from the array\n    return snapToMarks(val, marks);\n  }\n\n  return roundValToStep(minValue, step, val);\n}\n\n/**\n * round the value to step for the slider\n * @param minValue\n * @param step\n * @param val\n * @returns - rounded number\n */\nexport function roundValToStep(minValue: number, step: number, val: number): number {\n  if (!isNumber(step) || !isNumber(minValue)) {\n    return val;\n  }\n\n  const decimal = getRoundingDecimalFromStep(step);\n  const steps = Math.floor((val - minValue) / step);\n  let remain = val - (steps * step + minValue);\n\n  // has to round because javascript turns 0.1 into 0.9999999999999987\n  remain = Number(preciseRound(remain, 8));\n\n  let closest: number;\n  if (remain === 0) {\n    closest = val;\n  } else if (remain < step / 2) {\n    closest = steps * step + minValue;\n  } else {\n    closest = (steps + 1) * step + minValue;\n  }\n\n  // precise round return a string rounded to the defined decimal\n  const rounded = preciseRound(closest, decimal);\n\n  return Number(rounded);\n}\n\n/**\n * Get the value format based on field and format options\n * Used in render tooltip value\n */\nexport const defaultFormatter: FieldFormatter = v => (notNullorUndefined(v) ? String(v) : '');\n\nexport const floatFormatter = v => (isNumber(v) ? String(roundToFour(v)) : '');\n\nexport const FIELD_DISPLAY_FORMAT: {\n  [key: string]: FieldFormatter;\n} = {\n  [ALL_FIELD_TYPES.string]: defaultFormatter,\n  [ALL_FIELD_TYPES.timestamp]: defaultFormatter,\n  [ALL_FIELD_TYPES.integer]: defaultFormatter,\n  [ALL_FIELD_TYPES.real]: defaultFormatter,\n  [ALL_FIELD_TYPES.boolean]: defaultFormatter,\n  [ALL_FIELD_TYPES.date]: defaultFormatter,\n  [ALL_FIELD_TYPES.geojson]: d =>\n    typeof d === 'string'\n      ? d\n      : isPlainObject(d)\n      ? JSON.stringify(d)\n      : Array.isArray(d)\n      ? `[${String(d)}]`\n      : '',\n  [ALL_FIELD_TYPES.geoarrow]: d => d,\n  [ALL_FIELD_TYPES.object]: JSON.stringify,\n  [ALL_FIELD_TYPES.array]: JSON.stringify,\n  [ALL_FIELD_TYPES.h3]: defaultFormatter\n};\n\n/**\n * Parse field value and type and return a string representation\n */\nexport const parseFieldValue = (value: any, type: string): string => {\n  if (!notNullorUndefined(value)) {\n    return '';\n  }\n  return FIELD_DISPLAY_FORMAT[type] ? FIELD_DISPLAY_FORMAT[type](value) : String(value);\n};\n\n/**\n * Get the value format based on field and format options\n * Used in render tooltip value\n * @param format\n * @param field\n */\nexport function getFormatter(\n  format: string | Record<string, string> | null,\n  field?: Field\n): FieldFormatter {\n  if (!format) {\n    return defaultFormatter;\n  }\n  const tooltipFormat = Object.values(TOOLTIP_FORMATS).find(f => f[TOOLTIP_KEY] === format);\n\n  if (tooltipFormat) {\n    return applyDefaultFormat(tooltipFormat as TooltipFormat);\n  } else if (typeof format === 'string' && field) {\n    return applyCustomFormat(format, field);\n  }\n\n  return defaultFormatter;\n}\n\nexport function getColumnFormatter(\n  field: Pick<Field, 'type'> & Partial<Pick<Field, 'format' | 'displayFormat'>>\n): FieldFormatter {\n  const {format, displayFormat} = field;\n\n  if (!format && !displayFormat) {\n    return FIELD_DISPLAY_FORMAT[field.type];\n  }\n  const tooltipFormat = Object.values(TOOLTIP_FORMATS).find(f => f[TOOLTIP_KEY] === displayFormat);\n\n  if (tooltipFormat) {\n    return applyDefaultFormat(tooltipFormat);\n  } else if (typeof displayFormat === 'string' && field) {\n    return applyCustomFormat(displayFormat, field);\n  } else if (typeof displayFormat === 'object') {\n    return applyValueMap(displayFormat);\n  }\n\n  return defaultFormatter;\n}\n\nexport function applyValueMap(format) {\n  return v => format[v];\n}\n\nexport function applyDefaultFormat(tooltipFormat: TooltipFormat): (v: any) => string {\n  if (!tooltipFormat || !tooltipFormat.format) {\n    return defaultFormatter;\n  }\n\n  switch (tooltipFormat.type) {\n    case TOOLTIP_FORMAT_TYPES.DECIMAL:\n      return d3Format(tooltipFormat.format);\n    case TOOLTIP_FORMAT_TYPES.DATE:\n    case TOOLTIP_FORMAT_TYPES.DATE_TIME:\n      return datetimeFormatter(null)(tooltipFormat.format);\n    case TOOLTIP_FORMAT_TYPES.PERCENTAGE:\n      return v => `${d3Format(TOOLTIP_FORMATS.DECIMAL_DECIMAL_FIXED_2.format)(v)}%`;\n    case TOOLTIP_FORMAT_TYPES.BOOLEAN:\n      return getBooleanFormatter(tooltipFormat.format);\n    default:\n      return defaultFormatter;\n  }\n}\n\nexport function getBooleanFormatter(format: string): FieldFormatter {\n  switch (format) {\n    case '01':\n      return (v: boolean) => (v ? '1' : '0');\n    case 'yn':\n      return (v: boolean) => (v ? 'yes' : 'no');\n    default:\n      return defaultFormatter;\n  }\n}\n// Allow user to specify custom tooltip format via config\nexport function applyCustomFormat(format, field: {type?: string}): FieldFormatter {\n  switch (field.type) {\n    case ALL_FIELD_TYPES.real:\n    case ALL_FIELD_TYPES.integer:\n      return d3Format(format);\n    case ALL_FIELD_TYPES.date:\n    case ALL_FIELD_TYPES.timestamp:\n      return datetimeFormatter(null)(format);\n    default:\n      return v => v;\n  }\n}\n\nfunction formatLargeNumber(n) {\n  // SI-prefix with 4 significant digits\n  return d3Format('.4~s')(n);\n}\n\nexport function formatNumber(n: number, type?: string): string {\n  switch (type) {\n    case ALL_FIELD_TYPES.integer:\n      if (n < 0) {\n        return `-${formatNumber(-n, 'integer')}`;\n      }\n      if (n < 1000) {\n        return `${Math.round(n)}`;\n      }\n      if (n < 10 * 1000) {\n        return d3Format(',')(Math.round(n));\n      }\n      return formatLargeNumber(n);\n    case ALL_FIELD_TYPES.real:\n      if (n < 0) {\n        return `-${formatNumber(-n, 'number')}`;\n      }\n      if (n < 1000) {\n        return d3Format('.4~r')(n);\n      }\n      if (n < 10 * 1000) {\n        return d3Format(',.2~f')(n);\n      }\n      return formatLargeNumber(n);\n\n    default:\n      return formatNumber(n, 'real');\n  }\n}\n\nconst transformation = {\n  Y: Math.pow(10, 24),\n  Z: Math.pow(10, 21),\n  E: Math.pow(10, 18),\n  P: Math.pow(10, 15),\n  T: Math.pow(10, 12),\n  G: Math.pow(10, 9),\n  M: Math.pow(10, 6),\n  k: Math.pow(10, 3),\n  h: Math.pow(10, 2),\n  da: Math.pow(10, 1),\n  d: Math.pow(10, -1),\n  c: Math.pow(10, -2),\n  m: Math.pow(10, -3),\n  μ: Math.pow(10, -6),\n  n: Math.pow(10, -9),\n  p: Math.pow(10, -12),\n  f: Math.pow(10, -15),\n  a: Math.pow(10, -18),\n  z: Math.pow(10, -21),\n  y: Math.pow(10, -24)\n};\n\n/**\n * Convert a formatted number from string back to number\n */\nexport function reverseFormatNumber(str: string): number {\n  let returnValue: number | null = null;\n  const strNum = str.trim().replace(/,/g, '');\n  Object.entries(transformation).forEach(d => {\n    if (strNum.includes(d[0])) {\n      returnValue = parseFloat(strNum) * d[1];\n      return true;\n    }\n    return false;\n  });\n\n  // if no transformer found, convert to nuber regardless\n  return returnValue === null ? Number(strNum) : returnValue;\n}\n\n/**\n * Format epoch milliseconds with a format string\n * @type timezone\n */\nexport function datetimeFormatter(\n  timezone?: string | null\n): (format?: string) => (ts: number) => string {\n  return timezone\n    ? format => ts => moment.utc(ts).tz(timezone).format(format)\n    : // return empty string instead of 'Invalid date' if ts is undefined/null\n      format => ts => ts ? moment.utc(ts).format(format) : '';\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/dataset-utils.d.ts

@@ -0,0 +1,45 @@
+import { ProcessorResult, RGBColor, Field, FieldPair, TimeLabelFormat, TooltipFields, ProtoDataset } from '@kepler.gl/types';
+import { TooltipFormat } from '@kepler.gl/constants';
+export declare const datasetColorMaker: Generator<RGBColor, any, unknown>;
+/**
+ * Choose a field to use as the default color field of a layer.
+ *
+ * The heuristic is:
+ *
+ * First, exclude fields that are on the exclusion list and don't
+ * have names that suggest they contain metrics. Also exclude
+ * field names that are blank.
+ *
+ * Next, look for a field that is of real type and contains one
+ * of the preferred names (in order of the preferred names).
+ *
+ * Next, look for a field that is of integer type and contains
+ * one of the preferred names (in order of the preferred names).
+ *
+ * Next, look for the first field that is of real type (in order
+ * of field index).
+ *
+ * Next, look for the first field that is of integer type (in
+ * order of field index).
+ *
+ * It's possible no field will be chosen (i.e. because all fields
+ * are strings.)
+ *
+ * @param dataset
+ */
+export declare function findDefaultColorField({ fields, fieldPairs }: {
+    fields: Field[];
+    fieldPairs: FieldPair[];
+}): null | Field;
+/**
+ * Validate input data, adding missing field types, rename duplicate columns
+ */
+export declare function validateInputData(data: ProtoDataset['data']): ProcessorResult;
+export declare const addTimeLabel: (formats: TimeLabelFormat[]) => {
+    label: string;
+    id: string;
+    format: string | null;
+    type: string;
+}[];
+export declare function getFieldFormatLabels(fieldType?: string): TooltipFormat[];
+export declare const getFormatLabels: (fields: TooltipFields[], fieldName: string) => TooltipFormat[];