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

package/dist/data-scale-utils.js

@@ -0,0 +1,340 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.colorBreaksToColorMap = colorBreaksToColorMap;
+exports.colorMapToColorBreaks = colorMapToColorBreaks;
+exports.getDomainStepsbyZoom = getDomainStepsbyZoom;
+exports.getLayerColorScale = getLayerColorScale;
+exports.getLegendOfScale = getLegendOfScale;
+exports.getLinearDomain = getLinearDomain;
+exports.getLogDomain = getLogDomain;
+exports.getOrdinalDomain = getOrdinalDomain;
+exports.getOrdinalLegends = getOrdinalLegends;
+exports.getQuantLabelFormat = getQuantLabelFormat;
+exports.getQuantLegends = getQuantLegends;
+exports.getQuantileDomain = getQuantileDomain;
+exports.getScaleFunction = getScaleFunction;
+exports.getThresholdsFromQuantiles = getThresholdsFromQuantiles;
+exports.getVisualChannelScaleByZoom = getVisualChannelScaleByZoom;
+exports.initializeLayerColorMap = initializeLayerColorMap;
+exports.isDomainQuantile = isDomainQuantile;
+exports.isDomainStops = isDomainStops;
+exports.isNumericColorBreaks = isNumericColorBreaks;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _d3Array = require("d3-array");
+var _moment = _interopRequireDefault(require("moment"));
+var _commonUtils = require("@kepler.gl/common-utils");
+var _constants = require("@kepler.gl/constants");
+var _colorUtils = require("./color-utils");
+var _dataUtils = require("./data-utils");
+var _filterUtils = require("./filter-utils");
+var _utils = require("./utils");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+// import {Layer, VisualChannel, VisualChannelDomain} from '@kepler.gl/layers';
+// TODO isolate types - depends on @kepler.gl/layers
+
+/**
+ * return quantile domain for an array of data
+ */
+function getQuantileDomain(data, valueAccessor, sortFunc) {
+  var values = typeof valueAccessor === 'function' ? data.map(valueAccessor) : data;
+  return values.filter(_commonUtils.notNullorUndefined).sort(sortFunc);
+}
+
+/**
+ * return ordinal domain for a data container
+ */
+function getOrdinalDomain(dataContainer, valueAccessor) {
+  var values = dataContainer.mapIndex(valueAccessor);
+  return (0, _dataUtils.unique)(values).filter(_commonUtils.notNullorUndefined).sort();
+}
+
+/**
+ * return linear domain for an array of data
+ */
+function getLinearDomain(data, valueAccessor) {
+  var range = typeof valueAccessor === 'function' ? (0, _d3Array.extent)(data, valueAccessor) : (0, _d3Array.extent)(data);
+  return range.map(function (d, i) {
+    return d === undefined ? i : d;
+  });
+}
+
+/**
+ * return linear domain for an array of data. A log scale domain cannot contain 0
+ */
+function getLogDomain(data, valueAccessor) {
+  var _getLinearDomain = getLinearDomain(data, valueAccessor),
+    _getLinearDomain2 = (0, _slicedToArray2["default"])(_getLinearDomain, 2),
+    d0 = _getLinearDomain2[0],
+    d1 = _getLinearDomain2[1];
+  return [d0 === 0 ? 1e-5 : d0, d1];
+}
+/**
+ * whether field domain is stops
+ */
+function isDomainStops(domain) {
+  return (0, _utils.isPlainObject)(domain) && Array.isArray(domain.stops) && Array.isArray(domain.z);
+}
+/**
+ * whether field domain is quantiles
+ */
+function isDomainQuantile(domain) {
+  return (0, _utils.isPlainObject)(domain) && Array.isArray(domain.quantiles) && Array.isArray(domain.z);
+}
+
+/**
+ * get the domain at zoom
+ */
+function getThresholdsFromQuantiles(quantiles, buckets) {
+  var thresholds = [];
+  if (!Number.isFinite(buckets) || buckets < 1) {
+    return [quantiles[0], quantiles[quantiles.length - 1]];
+  }
+  for (var i = 1; i < buckets; i++) {
+    // position in sorted array
+    var position = i / buckets;
+    // @ts-ignore
+    thresholds.push((0, _d3Array.quantileSorted)(quantiles, position));
+  }
+  return thresholds;
+}
+
+/**
+ * get the domain at zoom
+ */
+function getDomainStepsbyZoom(domain, steps, z) {
+  var i = (0, _d3Array.bisectLeft)(steps, z);
+  if (steps[i] === z) {
+    // If z is an integer value exactly matching a step, return the corresponding domain
+    return domain[i];
+  }
+  // Otherwise, return the next coarsest domain
+  return domain[Math.max(i - 1, 0)];
+}
+
+/**
+ * Get d3 scale function
+ */
+function getScaleFunction(scale, range, domain, fixed) {
+  var scaleFunction = _constants.SCALE_FUNC[fixed ? 'linear' : scale]().domain(domain).range(fixed ? domain : range);
+  scaleFunction.scaleType = fixed ? 'linear' : scale;
+  return scaleFunction;
+}
+
+/**
+ * Get threshold scale color labels
+ */
+function getThresholdLabels(scale, labelFormat) {
+  var genLength = scale.range().length;
+  return scale.range().map(function (d, i) {
+    var invert = scale.invertExtent(d);
+    var inputs = [i === 0 ? null : (0, _dataUtils.reverseFormatNumber)(labelFormat(invert[0])), i === genLength - 1 ? null : (0, _dataUtils.reverseFormatNumber)(labelFormat(invert[1]))];
+    return {
+      // raw value
+      range: invert,
+      // formatted value
+      inputs: inputs,
+      label: i === 0 ? "Less than ".concat(labelFormat(invert[1])) : i === genLength - 1 ? "".concat(labelFormat(invert[0]), " or more") : "".concat(labelFormat(invert[0]), " to ").concat(labelFormat(invert[1]))
+    };
+  });
+}
+
+/**
+ * Get linear / quant scale color labels
+ */
+function getScaleLabels(scale, labelFormat) {
+  return scale.range().map(function (d, i) {
+    // @ts-ignore
+    var invert = scale.invertExtent(d);
+    var inputs = [(0, _dataUtils.reverseFormatNumber)(labelFormat(invert[0])), (0, _dataUtils.reverseFormatNumber)(labelFormat(invert[1]))];
+    return {
+      label: "".concat(labelFormat(invert[0]), " to ").concat(labelFormat(invert[1])),
+      // raw value
+      range: invert,
+      // formatted value
+      inputs: inputs
+    };
+  });
+}
+var customScaleLabelFormat = function customScaleLabelFormat(n) {
+  return n ? (0, _dataUtils.formatNumber)(n, 'real') : 'no value';
+};
+/**
+ * Get linear / quant scale color breaks
+ */
+function getQuantLegends(scale, labelFormat) {
+  if (typeof scale.invertExtent !== 'function') {
+    return [];
+  }
+  var labels = scale.scaleType === 'threshold' || scale.scaleType === 'custom' ? getThresholdLabels(scale, scale.scaleType === 'custom' ? customScaleLabelFormat : function (n) {
+    return n ? (0, _dataUtils.formatNumber)(n) : 'no value';
+  }) : getScaleLabels(scale, labelFormat);
+  var data = scale.range();
+  return labels.map(function (label, index) {
+    return _objectSpread({
+      data: Array.isArray(data[index]) ? (0, _colorUtils.rgbToHex)(data[index]) : data[index]
+    }, label);
+  });
+}
+
+/**
+ * Get ordinal color scale legends
+ */
+function getOrdinalLegends(scale) {
+  var domain = scale.domain();
+  var labels = scale.domain();
+  var data = domain.map(scale);
+  return data.map(function (datum, index) {
+    return {
+      data: (0, _colorUtils.isRgbColor)(datum) ? (0, _colorUtils.rgbToHex)(datum) : datum,
+      label: labels[index]
+    };
+  });
+}
+var defaultFormat = function defaultFormat(d) {
+  return d;
+};
+var getTimeLabelFormat = function getTimeLabelFormat(domain) {
+  var formatter = (0, _filterUtils.getTimeWidgetHintFormatter)(domain);
+  return function (val) {
+    return _moment["default"].utc(val).format(formatter);
+  };
+};
+function getQuantLabelFormat(domain, fieldType) {
+  // quant scale can only be assigned to linear Fields: real, timestamp, integer
+  return fieldType === _constants.ALL_FIELD_TYPES.timestamp ? getTimeLabelFormat(domain) : !fieldType ? defaultFormat : function (n) {
+    return (0, _dataUtils.isNumber)(n) ? (0, _dataUtils.formatNumber)(n, fieldType) : 'no value';
+  };
+}
+
+/**
+ * Get legends for scale
+ */
+function getLegendOfScale(_ref) {
+  var scale = _ref.scale,
+    scaleType = _ref.scaleType,
+    labelFormat = _ref.labelFormat,
+    fieldType = _ref.fieldType;
+  if (!scale || scale.byZoom) {
+    return [];
+  }
+  if (scaleType === _constants.SCALE_TYPES.ordinal) {
+    return getOrdinalLegends(scale);
+  }
+  var formatLabel = labelFormat || getQuantLabelFormat(scale.domain(), fieldType);
+  return getQuantLegends(scale, formatLabel);
+}
+
+/**
+ * Get color scale function
+ */
+function getLayerColorScale(_ref2) {
+  var range = _ref2.range,
+    domain = _ref2.domain,
+    scaleType = _ref2.scaleType,
+    layer = _ref2.layer;
+  if (range && domain && scaleType) {
+    return layer.getColorScale(scaleType, domain, range);
+  }
+  return null;
+}
+
+/**
+ * Convert colorRange.colorMap into color breaks UI input
+ */
+function initializeLayerColorMap(layer, visualChannel) {
+  var domain = layer.config[visualChannel.domain];
+  var range = layer.config.visConfig[visualChannel.range];
+  var scaleType = layer.config[visualChannel.scale];
+  var field = layer.config[visualChannel.field];
+  var scale = getLayerColorScale({
+    range: range,
+    domain: domain,
+    scaleType: scaleType,
+    layer: layer
+  });
+  var colorBreaks = getLegendOfScale({
+    scale: scale !== null && scale !== void 0 && scale.byZoom ? scale(0) : scale,
+    scaleType: scaleType,
+    fieldType: field.type
+  });
+  return colorBreaksToColorMap(colorBreaks);
+}
+
+/**
+ * Get visual chanel scale function if it's based on zoom
+ */
+function getVisualChannelScaleByZoom(_ref3) {
+  var _scale;
+  var scale = _ref3.scale,
+    layer = _ref3.layer,
+    mapState = _ref3.mapState;
+  if ((_scale = scale) !== null && _scale !== void 0 && _scale.byZoom) {
+    var _layer$meta;
+    var z = (_layer$meta = layer.meta) !== null && _layer$meta !== void 0 && _layer$meta.getZoom ? layer.meta.getZoom(mapState) : mapState === null || mapState === void 0 ? void 0 : mapState.zoom;
+    scale = Number.isFinite(z) ? scale(z) : null;
+  }
+  return scale;
+}
+
+/**
+ * Convert color breaks UI input into colorRange.colorMap
+ */
+function colorBreaksToColorMap(colorBreaks) {
+  var colorMap = colorBreaks.map(function (colorBreak, i) {
+    // [value, hex]
+    return [colorBreak.inputs ? i === colorBreaks.length - 1 ? null // last
+    : colorBreak.inputs[1] : colorBreak.label, colorBreak.data];
+  });
+
+  // @ts-ignore tuple
+  return colorMap;
+}
+
+/**
+ * Convert colorRange.colorMap into color breaks UI input
+ */
+function colorMapToColorBreaks(colorMap) {
+  if (!colorMap) {
+    return null;
+  }
+  var colorBreaks = colorMap.map(function (_ref4, i) {
+    var _ref5 = (0, _slicedToArray2["default"])(_ref4, 2),
+      value = _ref5[0],
+      color = _ref5[1];
+    var range = i === 0 ?
+    // first
+    [-Infinity, value] :
+    // last
+    i === colorMap.length - 1 ? [colorMap[i - 1][0], Infinity] :
+    // else
+    [colorMap[i - 1][0], value];
+    return {
+      data: color,
+      range: range,
+      inputs: range,
+      label:
+      // first
+      i === 0 ? "Less than ".concat(value) :
+      // last
+      i === colorMap.length - 1 ? "".concat(colorMap[i - 1][0], " or more") : "".concat(colorMap[i - 1][0], " to ").concat(value)
+    };
+  });
+
+  // @ts-ignore implement conversion for ordinal
+  return colorBreaks;
+}
+
+/**
+ * Whether color breaks is for numeric field
+ */
+function isNumericColorBreaks(colorBreaks) {
+  return Array.isArray(colorBreaks) && colorBreaks.length && colorBreaks[0].inputs;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_d3Array","require","_moment","_interopRequireDefault","_commonUtils","_constants","_colorUtils","_dataUtils","_filterUtils","_utils","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","getQuantileDomain","data","valueAccessor","sortFunc","values","map","notNullorUndefined","sort","getOrdinalDomain","dataContainer","mapIndex","unique","getLinearDomain","range","extent","d","i","undefined","getLogDomain","_getLinearDomain","_getLinearDomain2","_slicedToArray2","d0","d1","isDomainStops","domain","isPlainObject","Array","isArray","stops","z","isDomainQuantile","quantiles","getThresholdsFromQuantiles","buckets","thresholds","Number","isFinite","position","d3Quantile","getDomainStepsbyZoom","steps","bisectLeft","Math","max","getScaleFunction","scale","fixed","scaleFunction","SCALE_FUNC","scaleType","getThresholdLabels","labelFormat","genLength","invert","invertExtent","inputs","reverseFormatNumber","label","concat","getScaleLabels","customScaleLabelFormat","n","formatNumber","getQuantLegends","labels","index","rgbToHex","getOrdinalLegends","datum","isRgbColor","defaultFormat","getTimeLabelFormat","formatter","getTimeWidgetHintFormatter","val","moment","utc","format","getQuantLabelFormat","fieldType","ALL_FIELD_TYPES","timestamp","isNumber","getLegendOfScale","_ref","byZoom","SCALE_TYPES","ordinal","formatLabel","getLayerColorScale","_ref2","layer","getColorScale","initializeLayerColorMap","visualChannel","config","visConfig","field","colorBreaks","type","colorBreaksToColorMap","getVisualChannelScaleByZoom","_ref3","_scale","mapState","_layer$meta","meta","getZoom","zoom","colorMap","colorBreak","colorMapToColorBreaks","_ref4","_ref5","value","color","Infinity","isNumericColorBreaks"],"sources":["../src/data-scale-utils.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {bisectLeft, quantileSorted as d3Quantile, extent} from 'd3-array';\nimport moment from 'moment';\n\nimport {notNullorUndefined} from '@kepler.gl/common-utils';\nimport {ALL_FIELD_TYPES, ColorMap, ColorRange, SCALE_FUNC, SCALE_TYPES} from '@kepler.gl/constants';\n// import {Layer, VisualChannel, VisualChannelDomain} from '@kepler.gl/layers';\nimport {HexColor, MapState} from '@kepler.gl/types';\n\nimport {isRgbColor, rgbToHex} from './color-utils';\nimport {DataContainerInterface} from './data-container-interface';\nimport {formatNumber, isNumber, reverseFormatNumber, unique} from './data-utils';\nimport {getTimeWidgetHintFormatter} from './filter-utils';\nimport {isPlainObject} from './utils';\n\nexport type ColorBreak = {\n  data: HexColor;\n  label: string;\n  range: number[];\n  inputs: number[];\n};\nexport type ColorBreakOrdinal = {\n  data: HexColor;\n  label: string;\n};\n\nexport type D3ScaleFunction = Record<string, any> & ((x: any) => any);\n\n// TODO isolate types - depends on @kepler.gl/layers\ntype Layer = any;\ntype VisualChannel = any;\ntype VisualChannelDomain = any;\n\nexport type LabelFormat = (n: number) => string;\ntype dataValueAccessor = <T>(param: T) => T;\ntype dataContainerValueAccessor = (d: {index: number}, dc: DataContainerInterface) => any;\ntype sort = (a: any, b: any) => any;\n/**\n * return quantile domain for an array of data\n */\nexport function getQuantileDomain(\n  data: any[],\n  valueAccessor?: dataValueAccessor,\n  sortFunc?: sort\n): number[] {\n  const values = typeof valueAccessor === 'function' ? data.map(valueAccessor) : data;\n\n  return values.filter(notNullorUndefined).sort(sortFunc);\n}\n\n/**\n * return ordinal domain for a data container\n */\nexport function getOrdinalDomain(\n  dataContainer: DataContainerInterface,\n  valueAccessor: dataContainerValueAccessor\n): string[] {\n  const values = dataContainer.mapIndex(valueAccessor);\n\n  return unique(values).filter(notNullorUndefined).sort();\n}\n\n/**\n * return linear domain for an array of data\n */\nexport function getLinearDomain(\n  data: number[],\n  valueAccessor?: dataValueAccessor\n): [number, number] {\n  const range = typeof valueAccessor === 'function' ? extent(data, valueAccessor) : extent(data);\n  return range.map((d: undefined | number, i: number) => (d === undefined ? i : d)) as [\n    number,\n    number\n  ];\n}\n\n/**\n * return linear domain for an array of data. A log scale domain cannot contain 0\n */\nexport function getLogDomain(data: any[], valueAccessor: dataValueAccessor): [number, number] {\n  const [d0, d1] = getLinearDomain(data, valueAccessor);\n  return [d0 === 0 ? 1e-5 : d0, d1];\n}\n\nexport type DomainStops = {\n  stops: number[];\n  z: number[];\n};\n\n/**\n * whether field domain is stops\n */\nexport function isDomainStops(domain: unknown): domain is DomainStops {\n  return isPlainObject(domain) && Array.isArray(domain.stops) && Array.isArray(domain.z);\n}\n\nexport type DomainQuantiles = {\n  quantiles: number[];\n  z: number[];\n};\n\n/**\n * whether field domain is quantiles\n */\nexport function isDomainQuantile(domain: any): domain is DomainQuantiles {\n  return isPlainObject(domain) && Array.isArray(domain.quantiles) && Array.isArray(domain.z);\n}\n\n/**\n * get the domain at zoom\n */\nexport function getThresholdsFromQuantiles(\n  quantiles: number[],\n  buckets: number\n): (number | undefined)[] {\n  const thresholds = [];\n  if (!Number.isFinite(buckets) || buckets < 1) {\n    return [quantiles[0], quantiles[quantiles.length - 1]];\n  }\n  for (let i = 1; i < buckets; i++) {\n    // position in sorted array\n    const position = i / buckets;\n    // @ts-ignore\n    thresholds.push(d3Quantile(quantiles, position));\n  }\n\n  return thresholds;\n}\n\n/**\n * get the domain at zoom\n */\nexport function getDomainStepsbyZoom(domain: any[], steps: number[], z: number): any {\n  const i = bisectLeft(steps, z);\n\n  if (steps[i] === z) {\n    // If z is an integer value exactly matching a step, return the corresponding domain\n    return domain[i];\n  }\n  // Otherwise, return the next coarsest domain\n  return domain[Math.max(i - 1, 0)];\n}\n\n/**\n * Get d3 scale function\n */\nexport function getScaleFunction(\n  scale: string,\n  range: any[] | IterableIterator<any>,\n  domain: (number | undefined)[] | string[] | IterableIterator<any>,\n  fixed?: boolean\n): D3ScaleFunction {\n  const scaleFunction = SCALE_FUNC[fixed ? 'linear' : scale]()\n    .domain(domain)\n    .range(fixed ? domain : range);\n  scaleFunction.scaleType = fixed ? 'linear' : scale;\n  return scaleFunction;\n}\n\n/**\n * Get threshold scale color labels\n */\nfunction getThresholdLabels(\n  scale: D3ScaleFunction,\n  labelFormat: LabelFormat\n): Omit<ColorBreak, 'data'>[] {\n  const genLength = scale.range().length;\n  return scale.range().map((d, i) => {\n    const invert = scale.invertExtent(d);\n    const inputs = [\n      i === 0 ? null : reverseFormatNumber(labelFormat(invert[0])),\n      i === genLength - 1 ? null : reverseFormatNumber(labelFormat(invert[1]))\n    ];\n    return {\n      // raw value\n      range: invert,\n      // formatted value\n      inputs,\n      label:\n        i === 0\n          ? `Less than ${labelFormat(invert[1])}`\n          : i === genLength - 1\n          ? `${labelFormat(invert[0])} or more`\n          : `${labelFormat(invert[0])} to ${labelFormat(invert[1])}`\n    };\n  });\n}\n\n/**\n * Get linear / quant scale color labels\n */\nfunction getScaleLabels(\n  scale: D3ScaleFunction,\n  labelFormat: LabelFormat\n): Omit<ColorBreak, 'data'>[] {\n  return scale.range().map((d, i) => {\n    // @ts-ignore\n    const invert = scale.invertExtent(d);\n    const inputs = [\n      reverseFormatNumber(labelFormat(invert[0])),\n      reverseFormatNumber(labelFormat(invert[1]))\n    ];\n\n    return {\n      label: `${labelFormat(invert[0])} to ${labelFormat(invert[1])}`,\n      // raw value\n      range: invert,\n      // formatted value\n      inputs\n    };\n  });\n}\n\nconst customScaleLabelFormat = n => (n ? formatNumber(n, 'real') : 'no value');\n/**\n * Get linear / quant scale color breaks\n */\nexport function getQuantLegends(scale: D3ScaleFunction, labelFormat: LabelFormat): ColorBreak[] {\n  if (typeof scale.invertExtent !== 'function') {\n    return [];\n  }\n  const labels =\n    scale.scaleType === 'threshold' || scale.scaleType === 'custom'\n      ? getThresholdLabels(\n          scale,\n          scale.scaleType === 'custom'\n            ? customScaleLabelFormat\n            : n => (n ? formatNumber(n) : 'no value')\n        )\n      : getScaleLabels(scale, labelFormat);\n\n  const data = scale.range();\n\n  return labels.map((label, index) => ({\n    data: Array.isArray(data[index]) ? rgbToHex(data[index]) : data[index],\n    ...label\n  }));\n}\n\n/**\n * Get ordinal color scale legends\n */\nexport function getOrdinalLegends(scale: D3ScaleFunction): ColorBreakOrdinal[] {\n  const domain = scale.domain();\n  const labels = scale.domain();\n  const data = domain.map(scale);\n\n  return data.map((datum, index) => ({\n    data: isRgbColor(datum) ? rgbToHex(datum) : datum,\n    label: labels[index]\n  }));\n}\n\nconst defaultFormat = d => d;\n\nconst getTimeLabelFormat = domain => {\n  const formatter = getTimeWidgetHintFormatter(domain);\n  return val => moment.utc(val).format(formatter);\n};\n\nexport function getQuantLabelFormat(domain, fieldType) {\n  // quant scale can only be assigned to linear Fields: real, timestamp, integer\n  return fieldType === ALL_FIELD_TYPES.timestamp\n    ? getTimeLabelFormat(domain)\n    : !fieldType\n    ? defaultFormat\n    : n => (isNumber(n) ? formatNumber(n, fieldType) : 'no value');\n}\n\n/**\n * Get legends for scale\n */\nexport function getLegendOfScale({\n  scale,\n  scaleType,\n  labelFormat,\n  fieldType\n}: {\n  scale?: D3ScaleFunction | null;\n  scaleType: string;\n  labelFormat?: LabelFormat;\n  fieldType: string | null | undefined;\n}): ColorBreak[] | ColorBreakOrdinal[] {\n  if (!scale || scale.byZoom) {\n    return [];\n  }\n  if (scaleType === SCALE_TYPES.ordinal) {\n    return getOrdinalLegends(scale);\n  }\n\n  const formatLabel = labelFormat || getQuantLabelFormat(scale.domain(), fieldType);\n\n  return getQuantLegends(scale, formatLabel);\n}\n\n/**\n * Get color scale function\n */\nexport function getLayerColorScale({\n  range,\n  domain,\n  scaleType,\n  layer\n}: {\n  range: ColorRange | null | undefined;\n  domain: VisualChannelDomain;\n  scaleType: string;\n  layer: Layer;\n  isFixed?: boolean;\n}): D3ScaleFunction | null {\n  if (range && domain && scaleType) {\n    return layer.getColorScale(scaleType, domain, range);\n  }\n  return null;\n}\n\n/**\n * Convert colorRange.colorMap into color breaks UI input\n */\nexport function initializeLayerColorMap(layer: Layer, visualChannel: VisualChannel): ColorMap {\n  const domain = layer.config[visualChannel.domain];\n  const range = layer.config.visConfig[visualChannel.range];\n  const scaleType = layer.config[visualChannel.scale];\n  const field = layer.config[visualChannel.field];\n\n  const scale = getLayerColorScale({\n    range,\n    domain,\n    scaleType,\n    layer\n  });\n\n  const colorBreaks = getLegendOfScale({\n    scale: scale?.byZoom ? scale(0) : scale,\n    scaleType,\n    fieldType: field.type\n  });\n  return colorBreaksToColorMap(colorBreaks);\n}\n\n/**\n * Get visual chanel scale function if it's based on zoom\n */\nexport function getVisualChannelScaleByZoom({\n  scale,\n  layer,\n  mapState\n}: {\n  scale: D3ScaleFunction | null;\n  layer: Layer;\n  mapState?: MapState;\n}): D3ScaleFunction | null {\n  if (scale?.byZoom) {\n    const z = layer.meta?.getZoom ? layer.meta.getZoom(mapState) : mapState?.zoom;\n    scale = Number.isFinite(z) ? scale(z) : null;\n  }\n  return scale;\n}\n\n/**\n * Convert color breaks UI input into colorRange.colorMap\n */\nexport function colorBreaksToColorMap(colorBreaks: ColorBreak[] | ColorBreakOrdinal[]): ColorMap {\n  const colorMap = colorBreaks.map((colorBreak, i) => {\n    // [value, hex]\n    return [\n      colorBreak.inputs\n        ? i === colorBreaks.length - 1\n          ? null // last\n          : colorBreak.inputs[1]\n        : colorBreak.label,\n      colorBreak.data\n    ];\n  });\n\n  // @ts-ignore tuple\n  return colorMap;\n}\n\n/**\n * Convert colorRange.colorMap into color breaks UI input\n */\nexport function colorMapToColorBreaks(colorMap?: ColorMap): ColorBreak[] | null {\n  if (!colorMap) {\n    return null;\n  }\n  const colorBreaks = colorMap.map(([value, color], i) => {\n    const range =\n      i === 0\n        ? // first\n          [-Infinity, value]\n        : // last\n        i === colorMap.length - 1\n        ? [colorMap[i - 1][0], Infinity]\n        : // else\n          [colorMap[i - 1][0], value];\n    return {\n      data: color,\n      range,\n      inputs: range,\n      label:\n        // first\n        i === 0\n          ? `Less than ${value}`\n          : // last\n          i === colorMap.length - 1\n          ? `${colorMap[i - 1][0]} or more`\n          : `${colorMap[i - 1][0]} to ${value}`\n    };\n  });\n\n  // @ts-ignore implement conversion for ordinal\n  return colorBreaks;\n}\n\n/**\n * Whether color breaks is for numeric field\n */\nexport function isNumericColorBreaks(colorBreaks: unknown): colorBreaks is ColorBreak[] {\n  return Array.isArray(colorBreaks) && colorBreaks.length && colorBreaks[0].inputs;\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/data-utils.d.ts

@@ -0,0 +1,98 @@
+import { TooltipFormat } from '@kepler.gl/constants';
+import { Field, Millisecond } from '@kepler.gl/types';
+export declare type FieldFormatter = (value: any) => string;
+/**
+ * simple getting unique values of an array
+ *
+ * @param values
+ * @returns unique values
+ */
+export declare function unique<T>(values: T[]): T[];
+export declare function getLatLngBounds(points: number[][], idx: number, limit: [number, number]): [number, number] | null;
+export declare function clamp([min, max]: [number, number], val?: number): number;
+export declare function getSampleData(data: any, sampleSize?: number, getValue?: (d: any) => any): any[];
+/**
+ * Convert different time format to unix milliseconds
+ */
+export declare function timeToUnixMilli(value: string | number | Date, format: string): Millisecond | null;
+/**
+ * Whether d is a number, this filtered out NaN as well
+ */
+export declare function isNumber(d: unknown): d is number;
+/**
+ * whether object has property
+ * @param {string} prop
+ * @returns {boolean} - yes or no
+ */
+export declare function hasOwnProperty<X extends object, Y extends PropertyKey>(obj: X, prop: Y): obj is X & Record<Y, unknown>;
+export declare function numberSort(a: number, b: number): number;
+export declare function getSortingFunction(fieldType: string): typeof numberSort | undefined;
+/**
+ * round number with exact number of decimals
+ * return as a string
+ */
+export declare function preciseRound(num: number, decimals: number): string;
+/**
+ * round a giving number at most 4 decimal places
+ * e.g. 10 -> 10, 1.12345 -> 1.2345, 2.0 -> 2
+ */
+export declare function roundToFour(num: number): number;
+/**
+ * get number of decimals to round to for slider from step
+ * @param step
+ * @returns- number of decimal
+ */
+export declare function getRoundingDecimalFromStep(step: number): number;
+/**
+ * If marks is provided, snap to marks, if not normalize to step
+ * @param val
+ * @param minValue
+ * @param step
+ * @param marks
+ */
+export declare function normalizeSliderValue(val: number, minValue: number, step: number, marks?: number[] | null): number;
+/**
+ * round the value to step for the slider
+ * @param minValue
+ * @param step
+ * @param val
+ * @returns - rounded number
+ */
+export declare function roundValToStep(minValue: number, step: number, val: number): number;
+/**
+ * Get the value format based on field and format options
+ * Used in render tooltip value
+ */
+export declare const defaultFormatter: FieldFormatter;
+export declare const floatFormatter: (v: any) => string;
+export declare const FIELD_DISPLAY_FORMAT: {
+    [key: string]: FieldFormatter;
+};
+/**
+ * Parse field value and type and return a string representation
+ */
+export declare const parseFieldValue: (value: any, type: string) => string;
+/**
+ * Get the value format based on field and format options
+ * Used in render tooltip value
+ * @param format
+ * @param field
+ */
+export declare function getFormatter(format: string | Record<string, string> | null, field?: Field): FieldFormatter;
+export declare function getColumnFormatter(field: Pick<Field, 'type'> & Partial<Pick<Field, 'format' | 'displayFormat'>>): FieldFormatter;
+export declare function applyValueMap(format: any): (v: any) => any;
+export declare function applyDefaultFormat(tooltipFormat: TooltipFormat): (v: any) => string;
+export declare function getBooleanFormatter(format: string): FieldFormatter;
+export declare function applyCustomFormat(format: any, field: {
+    type?: string;
+}): FieldFormatter;
+export declare function formatNumber(n: number, type?: string): string;
+/**
+ * Convert a formatted number from string back to number
+ */
+export declare function reverseFormatNumber(str: string): number;
+/**
+ * Format epoch milliseconds with a format string
+ * @type timezone
+ */
+export declare function datetimeFormatter(timezone?: string | null): (format?: string) => (ts: number) => string;