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

package/dist/dataset-utils.js

@@ -0,0 +1,313 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.datasetColorMaker = exports.addTimeLabel = void 0;
+exports.findDefaultColorField = findDefaultColorField;
+exports.getFieldFormatLabels = getFieldFormatLabels;
+exports.getFormatLabels = void 0;
+exports.validateInputData = validateInputData;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _constants = require("@kepler.gl/constants");
+var _commonUtils = require("@kepler.gl/common-utils");
+var _typeAnalyzer = require("type-analyzer");
+var _assert = _interopRequireDefault(require("assert"));
+var _utils = require("./utils");
+var _dataUtils = require("./data-utils");
+var _format = require("./format");
+var _colorUtils = require("./color-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; }
+var _marked = /*#__PURE__*/_regenerator["default"].mark(generateColor); // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+// apply a color for each dataset
+// to use as label colors
+var datasetColors = ['#8F2FBF', '#005CFF', '#C06C84', '#F8B195', '#547A82', '#3EACA8', '#A2D4AB'].map(_colorUtils.hexToRgb);
+
+/**
+ * Random color generator
+ */
+function generateColor() {
+  var index;
+  return _regenerator["default"].wrap(function generateColor$(_context) {
+    while (1) switch (_context.prev = _context.next) {
+      case 0:
+        index = 0;
+      case 1:
+        if (!(index < datasetColors.length + 1)) {
+          _context.next = 7;
+          break;
+        }
+        if (index === datasetColors.length) {
+          index = 0;
+        }
+        _context.next = 5;
+        return datasetColors[index++];
+      case 5:
+        _context.next = 1;
+        break;
+      case 7:
+      case "end":
+        return _context.stop();
+    }
+  }, _marked);
+}
+var datasetColorMaker = exports.datasetColorMaker = generateColor();
+
+/**
+ * Field name prefixes and suffixes which should not be considered
+ * as metrics. Fields will still be included if a 'metric word'
+ * is found on the field name, however.
+ */
+var EXCLUDED_DEFAULT_FIELDS = [
+// Serial numbers and identification numbers
+'_id', 'id', 'index', 'uuid', 'guid', 'uid', 'gid', 'serial',
+// Geographic IDs are unlikely to be interesting to color
+'zip', 'code', 'post', 'region', 'fips', 'cbgs', 'h3', 's2',
+// Geographic coords (but not z/elevation/altitude
+// since that might be a metric)
+'lat', 'lon', 'lng', 'latitude', 'longitude', '_x', '_y'];
+
+/**
+ * Prefixes and suffixes that indicate a field is a metric.
+ *
+ * Note that these are in order of preference, first being
+ * most preferred.
+ */
+var METRIC_DEFAULT_FIELDS = ['metric', 'value', 'sum', 'count', 'unique', 'mean', 'mode', 'median', 'max', 'min', 'deviation', 'variance', 'p99', 'p95', 'p75', 'p50', 'p25', 'p05',
+// Abbreviations are less preferred
+'cnt', 'val'];
+
+/**
+ * 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
+ */
+function findDefaultColorField(_ref) {
+  var fields = _ref.fields,
+    _ref$fieldPairs = _ref.fieldPairs,
+    fieldPairs = _ref$fieldPairs === void 0 ? [] : _ref$fieldPairs;
+  var fieldsWithoutExcluded = fields.filter(function (field) {
+    if (field.type !== _constants.ALL_FIELD_TYPES.real && field.type !== _constants.ALL_FIELD_TYPES.integer) {
+      // Only select numeric fields.
+      return false;
+    }
+    if (fieldPairs.find(function (pair) {
+      return pair.pair.lat.value === field.name || pair.pair.lng.value === field.name;
+    })) {
+      // Do not permit lat, lon fields
+      return false;
+    }
+    var normalizedFieldName = field.name.toLowerCase();
+    if (normalizedFieldName === '') {
+      // Special case excluded name when the name is blank.
+      return false;
+    }
+    var hasExcluded = EXCLUDED_DEFAULT_FIELDS.find(function (f) {
+      return normalizedFieldName.startsWith(f) || normalizedFieldName.endsWith(f);
+    });
+    var hasInclusion = METRIC_DEFAULT_FIELDS.find(function (f) {
+      return normalizedFieldName.startsWith(f) || normalizedFieldName.endsWith(f);
+    });
+    return !hasExcluded || hasInclusion;
+  });
+  var sortedFields = fieldsWithoutExcluded.sort(function (left, right) {
+    var normalizedLeft = left.name.toLowerCase();
+    var normalizedRight = right.name.toLowerCase();
+    var leftHasInclusion = METRIC_DEFAULT_FIELDS.findIndex(function (f) {
+      return normalizedLeft.startsWith(f) || normalizedLeft.endsWith(f);
+    });
+    var rightHasInclusion = METRIC_DEFAULT_FIELDS.findIndex(function (f) {
+      return normalizedRight.startsWith(f) || normalizedRight.endsWith(f);
+    });
+    if (leftHasInclusion !== rightHasInclusion) {
+      if (leftHasInclusion === -1) {
+        // Elements that do not have the inclusion list should go after those that do.
+        return 1;
+      } else if (rightHasInclusion === -1) {
+        // Elements that do have the inclusion list should go before those that don't.
+        return -1;
+      }
+      // Compare based on order in the inclusion list
+      return leftHasInclusion - rightHasInclusion;
+    }
+
+    // Compare based on type
+    if (left.type !== right.type) {
+      if (left.type === _constants.ALL_FIELD_TYPES.real) {
+        return -1;
+      }
+      // left is an integer and right is not
+      // and reals come before integers
+      return 1;
+    }
+
+    // Finally, order based on the order in the datasets columns
+    // @ts-expect-error
+    return left.index - right.index;
+  });
+  if (sortedFields.length) {
+    // There was a best match
+    return sortedFields[0];
+  }
+  // No matches
+  return null;
+}
+
+/**
+ * Validate input data, adding missing field types, rename duplicate columns
+ */
+function validateInputData(data) {
+  if (!(0, _utils.isPlainObject)(data)) {
+    (0, _assert["default"])('addDataToMap Error: dataset.data cannot be null');
+    return null;
+  } else if (!Array.isArray(data.fields)) {
+    (0, _assert["default"])('addDataToMap Error: expect dataset.data.fields to be an array');
+    return null;
+  } else if (!Array.isArray(data.rows)) {
+    (0, _assert["default"])('addDataToMap Error: expect dataset.data.rows to be an array');
+    return null;
+  }
+  var fields = data.fields,
+    rows = data.rows,
+    cols = data.cols;
+
+  // check if all fields has name, format and type
+  var allValid = fields.every(function (f, i) {
+    if (!(0, _utils.isPlainObject)(f)) {
+      (0, _assert["default"])("fields needs to be an array of object, but find ".concat((0, _typeof2["default"])(f)));
+      fields[i] = {
+        name: "column_".concat(i),
+        type: _constants.ALL_FIELD_TYPES.string
+      };
+    }
+    if (!f.name) {
+      (0, _assert["default"])("field.name is required but missing in ".concat(JSON.stringify(f)));
+      // assign a name
+      fields[i].name = "column_".concat(i);
+    }
+    if (!f.type || !_constants.ALL_FIELD_TYPES[f.type]) {
+      (0, _assert["default"])("unknown field type ".concat(f.type));
+      return false;
+    }
+    if (!fields.every(function (field) {
+      return field.analyzerType;
+    })) {
+      (0, _assert["default"])('field missing analyzerType');
+      return false;
+    }
+
+    // check time format is correct based on first 10 not empty element
+    if (f.type === _constants.ALL_FIELD_TYPES.timestamp) {
+      var sample = findNonEmptyRowsAtField(rows, i, 10).map(function (r) {
+        return {
+          ts: r[i]
+        };
+      });
+      var analyzedType = _typeAnalyzer.Analyzer.computeColMeta(sample)[0];
+      return analyzedType && analyzedType.category === 'TIME' && analyzedType.format === f.format;
+    }
+
+    // check existing string field is H3 type
+    if (f.type === _constants.ALL_FIELD_TYPES.string) {
+      var _sample = findNonEmptyRowsAtField(rows, i, 10).map(function (r) {
+        return r[i];
+      });
+      return _sample.every(function (item) {
+        return !(0, _commonUtils.h3IsValid)(item);
+      });
+    }
+    return true;
+  });
+  if (allValid) {
+    return {
+      rows: rows,
+      fields: fields,
+      cols: cols
+    };
+  }
+
+  // if any field has missing type, recalculate it for everyone
+  // because we simply lost faith in humanity
+  var sampleData = (0, _commonUtils.getSampleForTypeAnalyze)({
+    fields: fields.map(function (f) {
+      return f.name;
+    }),
+    rows: rows
+  });
+  var fieldOrder = fields.map(function (f) {
+    return f.name;
+  });
+  var meta = (0, _commonUtils.getFieldsFromData)(sampleData, fieldOrder);
+  var updatedFields = fields.map(function (f, i) {
+    return _objectSpread(_objectSpread({}, f), {}, {
+      type: meta[i].type,
+      format: meta[i].format,
+      analyzerType: meta[i].analyzerType
+    });
+  });
+  return {
+    fields: updatedFields,
+    rows: rows
+  };
+}
+function findNonEmptyRowsAtField(rows, fieldIdx, total) {
+  var sample = [];
+  var i = 0;
+  while (sample.length < total && i < rows.length) {
+    var _rows$i;
+    if ((0, _commonUtils.notNullorUndefined)((_rows$i = rows[i]) === null || _rows$i === void 0 ? void 0 : _rows$i[fieldIdx])) {
+      sample.push(rows[i]);
+    }
+    i++;
+  }
+  return sample;
+}
+var TIME_DISPLAY = '2020-05-11 14:00';
+var addTimeLabel = exports.addTimeLabel = function addTimeLabel(formats) {
+  return formats.map(function (f) {
+    return _objectSpread(_objectSpread({}, f), {}, {
+      label: f.type === _constants.TOOLTIP_FORMAT_TYPES.DATE_TIME || f.type === _constants.TOOLTIP_FORMAT_TYPES.DATE ? (0, _dataUtils.getFormatter)((0, _format.getFormatValue)(f))(TIME_DISPLAY) : f.label
+    });
+  });
+};
+function getFieldFormatLabels(fieldType) {
+  var tooltipTypes = fieldType && _constants.FIELD_OPTS[fieldType].format.tooltip || [];
+  var formatLabels = Object.values(_constants.TOOLTIP_FORMATS).filter(function (t) {
+    return tooltipTypes.includes(t.type);
+  });
+  return addTimeLabel(formatLabels);
+}
+var getFormatLabels = exports.getFormatLabels = function getFormatLabels(fields, fieldName) {
+  var _fields$find;
+  var fieldType = (_fields$find = fields.find(function (f) {
+    return f.name === fieldName;
+  })) === null || _fields$find === void 0 ? void 0 : _fields$find.type;
+  return getFieldFormatLabels(fieldType);
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_constants","require","_commonUtils","_typeAnalyzer","_assert","_interopRequireDefault","_utils","_dataUtils","_format","_colorUtils","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","_marked","_regenerator","mark","generateColor","datasetColors","map","hexToRgb","index","wrap","generateColor$","_context","prev","next","stop","datasetColorMaker","exports","EXCLUDED_DEFAULT_FIELDS","METRIC_DEFAULT_FIELDS","findDefaultColorField","_ref","fields","_ref$fieldPairs","fieldPairs","fieldsWithoutExcluded","field","type","ALL_FIELD_TYPES","real","integer","find","pair","lat","value","name","lng","normalizedFieldName","toLowerCase","hasExcluded","f","startsWith","endsWith","hasInclusion","sortedFields","sort","left","right","normalizedLeft","normalizedRight","leftHasInclusion","findIndex","rightHasInclusion","validateInputData","data","isPlainObject","assert","Array","isArray","rows","cols","allValid","every","i","concat","_typeof2","string","JSON","stringify","analyzerType","timestamp","sample","findNonEmptyRowsAtField","ts","analyzedType","Analyzer","computeColMeta","category","format","item","h3IsValid","sampleData","getSampleForTypeAnalyze","fieldOrder","meta","getFieldsFromData","updatedFields","fieldIdx","total","_rows$i","notNullorUndefined","TIME_DISPLAY","addTimeLabel","formats","label","TOOLTIP_FORMAT_TYPES","DATE_TIME","DATE","getFormatter","getFormatValue","getFieldFormatLabels","fieldType","tooltipTypes","FIELD_OPTS","tooltip","formatLabels","values","TOOLTIP_FORMATS","includes","getFormatLabels","fieldName","_fields$find"],"sources":["../src/dataset-utils.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {\n  ALL_FIELD_TYPES,\n  FIELD_OPTS,\n  TOOLTIP_FORMATS,\n  TOOLTIP_FORMAT_TYPES\n} from '@kepler.gl/constants';\nimport {getSampleForTypeAnalyze, getFieldsFromData} from '@kepler.gl/common-utils';\nimport {Analyzer} from 'type-analyzer';\nimport assert from 'assert';\n\nimport {\n  ProcessorResult,\n  RGBColor,\n  Field,\n  FieldPair,\n  TimeLabelFormat,\n  TooltipFields,\n  ProtoDataset\n} from '@kepler.gl/types';\nimport {TooltipFormat} from '@kepler.gl/constants';\nimport {notNullorUndefined, h3IsValid} from '@kepler.gl/common-utils';\n\nimport {isPlainObject} from './utils';\nimport {getFormatter} from './data-utils';\nimport {getFormatValue} from './format';\nimport {hexToRgb} from './color-utils';\n\n// apply a color for each dataset\n// to use as label colors\nconst datasetColors = [\n  '#8F2FBF',\n  '#005CFF',\n  '#C06C84',\n  '#F8B195',\n  '#547A82',\n  '#3EACA8',\n  '#A2D4AB'\n].map(hexToRgb);\n\n/**\n * Random color generator\n */\nfunction* generateColor(): Generator<RGBColor> {\n  let index = 0;\n  while (index < datasetColors.length + 1) {\n    if (index === datasetColors.length) {\n      index = 0;\n    }\n    yield datasetColors[index++];\n  }\n}\n\nexport const datasetColorMaker = generateColor();\n\n/**\n * Field name prefixes and suffixes which should not be considered\n * as metrics. Fields will still be included if a 'metric word'\n * is found on the field name, however.\n */\nconst EXCLUDED_DEFAULT_FIELDS = [\n  // Serial numbers and identification numbers\n  '_id',\n  'id',\n  'index',\n  'uuid',\n  'guid',\n  'uid',\n  'gid',\n  'serial',\n  // Geographic IDs are unlikely to be interesting to color\n  'zip',\n  'code',\n  'post',\n  'region',\n  'fips',\n  'cbgs',\n  'h3',\n  's2',\n  // Geographic coords (but not z/elevation/altitude\n  // since that might be a metric)\n  'lat',\n  'lon',\n  'lng',\n  'latitude',\n  'longitude',\n  '_x',\n  '_y'\n];\n\n/**\n * Prefixes and suffixes that indicate a field is a metric.\n *\n * Note that these are in order of preference, first being\n * most preferred.\n */\nconst METRIC_DEFAULT_FIELDS = [\n  'metric',\n  'value',\n  'sum',\n  'count',\n  'unique',\n  'mean',\n  'mode',\n  'median',\n  'max',\n  'min',\n  'deviation',\n  'variance',\n  'p99',\n  'p95',\n  'p75',\n  'p50',\n  'p25',\n  'p05',\n  // Abbreviations are less preferred\n  'cnt',\n  'val'\n];\n\n/**\n * Choose a field to use as the default color field of a layer.\n *\n * The heuristic is:\n *\n * First, exclude fields that are on the exclusion list and don't\n * have names that suggest they contain metrics. Also exclude\n * field names that are blank.\n *\n * Next, look for a field that is of real type and contains one\n * of the preferred names (in order of the preferred names).\n *\n * Next, look for a field that is of integer type and contains\n * one of the preferred names (in order of the preferred names).\n *\n * Next, look for the first field that is of real type (in order\n * of field index).\n *\n * Next, look for the first field that is of integer type (in\n * order of field index).\n *\n * It's possible no field will be chosen (i.e. because all fields\n * are strings.)\n *\n * @param dataset\n */\nexport function findDefaultColorField({\n  fields,\n  fieldPairs = []\n}: {\n  fields: Field[];\n  fieldPairs: FieldPair[];\n}): null | Field {\n  const fieldsWithoutExcluded = fields.filter(field => {\n    if (field.type !== ALL_FIELD_TYPES.real && field.type !== ALL_FIELD_TYPES.integer) {\n      // Only select numeric fields.\n      return false;\n    }\n    if (\n      fieldPairs.find(\n        pair => pair.pair.lat.value === field.name || pair.pair.lng.value === field.name\n      )\n    ) {\n      // Do not permit lat, lon fields\n      return false;\n    }\n\n    const normalizedFieldName = field.name.toLowerCase();\n    if (normalizedFieldName === '') {\n      // Special case excluded name when the name is blank.\n      return false;\n    }\n    const hasExcluded = EXCLUDED_DEFAULT_FIELDS.find(\n      f => normalizedFieldName.startsWith(f) || normalizedFieldName.endsWith(f)\n    );\n    const hasInclusion = METRIC_DEFAULT_FIELDS.find(\n      f => normalizedFieldName.startsWith(f) || normalizedFieldName.endsWith(f)\n    );\n    return !hasExcluded || hasInclusion;\n  });\n\n  const sortedFields = fieldsWithoutExcluded.sort((left, right) => {\n    const normalizedLeft = left.name.toLowerCase();\n    const normalizedRight = right.name.toLowerCase();\n    const leftHasInclusion = METRIC_DEFAULT_FIELDS.findIndex(\n      f => normalizedLeft.startsWith(f) || normalizedLeft.endsWith(f)\n    );\n    const rightHasInclusion = METRIC_DEFAULT_FIELDS.findIndex(\n      f => normalizedRight.startsWith(f) || normalizedRight.endsWith(f)\n    );\n    if (leftHasInclusion !== rightHasInclusion) {\n      if (leftHasInclusion === -1) {\n        // Elements that do not have the inclusion list should go after those that do.\n        return 1;\n      } else if (rightHasInclusion === -1) {\n        // Elements that do have the inclusion list should go before those that don't.\n        return -1;\n      }\n      // Compare based on order in the inclusion list\n      return leftHasInclusion - rightHasInclusion;\n    }\n\n    // Compare based on type\n    if (left.type !== right.type) {\n      if (left.type === ALL_FIELD_TYPES.real) {\n        return -1;\n      }\n      // left is an integer and right is not\n      // and reals come before integers\n      return 1;\n    }\n\n    // Finally, order based on the order in the datasets columns\n    // @ts-expect-error\n    return left.index - right.index;\n  });\n\n  if (sortedFields.length) {\n    // There was a best match\n    return sortedFields[0];\n  }\n  // No matches\n  return null;\n}\n\n/**\n * Validate input data, adding missing field types, rename duplicate columns\n */\nexport function validateInputData(data: ProtoDataset['data']): ProcessorResult {\n  if (!isPlainObject(data)) {\n    assert('addDataToMap Error: dataset.data cannot be null');\n    return null;\n  } else if (!Array.isArray(data.fields)) {\n    assert('addDataToMap Error: expect dataset.data.fields to be an array');\n    return null;\n  } else if (!Array.isArray(data.rows)) {\n    assert('addDataToMap Error: expect dataset.data.rows to be an array');\n    return null;\n  }\n\n  const {fields, rows, cols} = data;\n\n  // check if all fields has name, format and type\n  const allValid = fields.every((f, i) => {\n    if (!isPlainObject(f)) {\n      assert(`fields needs to be an array of object, but find ${typeof f}`);\n      fields[i] = {name: `column_${i}`, type: ALL_FIELD_TYPES.string};\n    }\n\n    if (!f.name) {\n      assert(`field.name is required but missing in ${JSON.stringify(f)}`);\n      // assign a name\n      fields[i].name = `column_${i}`;\n    }\n\n    if (!f.type || !ALL_FIELD_TYPES[f.type]) {\n      assert(`unknown field type ${f.type}`);\n      return false;\n    }\n\n    if (!fields.every(field => field.analyzerType)) {\n      assert('field missing analyzerType');\n      return false;\n    }\n\n    // check time format is correct based on first 10 not empty element\n    if (f.type === ALL_FIELD_TYPES.timestamp) {\n      const sample = findNonEmptyRowsAtField(rows, i, 10).map(r => ({ts: r[i]}));\n      const analyzedType = Analyzer.computeColMeta(sample)[0];\n      return analyzedType && analyzedType.category === 'TIME' && analyzedType.format === f.format;\n    }\n\n    // check existing string field is H3 type\n    if (f.type === ALL_FIELD_TYPES.string) {\n      const sample = findNonEmptyRowsAtField(rows, i, 10).map(r => r[i]);\n      return sample.every(item => !h3IsValid(item));\n    }\n\n    return true;\n  });\n\n  if (allValid) {\n    return {rows, fields, cols};\n  }\n\n  // if any field has missing type, recalculate it for everyone\n  // because we simply lost faith in humanity\n  const sampleData = getSampleForTypeAnalyze({\n    fields: fields.map(f => f.name),\n    rows\n  });\n  const fieldOrder = fields.map(f => f.name);\n  const meta = getFieldsFromData(sampleData, fieldOrder);\n  const updatedFields = fields.map((f, i) => ({\n    ...f,\n    type: meta[i].type,\n    format: meta[i].format,\n    analyzerType: meta[i].analyzerType\n  }));\n\n  return {fields: updatedFields, rows};\n}\n\nfunction findNonEmptyRowsAtField(rows: unknown[][], fieldIdx: number, total: number): any[] {\n  const sample: any[] = [];\n  let i = 0;\n  while (sample.length < total && i < rows.length) {\n    if (notNullorUndefined(rows[i]?.[fieldIdx])) {\n      sample.push(rows[i]);\n    }\n    i++;\n  }\n  return sample;\n}\n\nconst TIME_DISPLAY = '2020-05-11 14:00';\n\nexport const addTimeLabel = (formats: TimeLabelFormat[]) =>\n  formats.map(f => ({\n    ...f,\n    label:\n      f.type === TOOLTIP_FORMAT_TYPES.DATE_TIME || f.type === TOOLTIP_FORMAT_TYPES.DATE\n        ? getFormatter(getFormatValue(f))(TIME_DISPLAY)\n        : f.label\n  }));\n\nexport function getFieldFormatLabels(fieldType?: string): TooltipFormat[] {\n  const tooltipTypes = (fieldType && FIELD_OPTS[fieldType].format.tooltip) || [];\n  const formatLabels: TimeLabelFormat[] = Object.values(TOOLTIP_FORMATS).filter(t =>\n    tooltipTypes.includes(t.type)\n  );\n  return addTimeLabel(formatLabels);\n}\n\nexport const getFormatLabels = (fields: TooltipFields[], fieldName: string): TooltipFormat[] => {\n  const fieldType = fields.find(f => f.name === fieldName)?.type;\n  return getFieldFormatLabels(fieldType);\n};\n"],"mappings":"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","ignoreList":[]}

package/dist/dom-to-image.d.ts

@@ -0,0 +1,73 @@
+declare const domtoimage: {
+    toSvg: typeof toSvg;
+    toPng: typeof toPng;
+    toJpeg: typeof toJpeg;
+    toBlob: typeof toBlob;
+    toPixelData: typeof toPixelData;
+    impl: {
+        fontFaces: {
+            resolveAll: () => Promise<string>;
+            impl: {
+                readAll: () => Promise<any>;
+            };
+        };
+        images: {
+            inlineAll: (node: any) => any;
+            impl: {
+                newImage: (element: any) => {
+                    inline: (get: any) => Promise<unknown>;
+                };
+            };
+        };
+        inliner: {
+            inlineAll: (string: any, baseUrl: any, get: any) => Promise<any>;
+            shouldProcess: (string: any) => boolean;
+            impl: {
+                readUrls: (string: any) => string[];
+                inline: (string: any, url: any, baseUrl: any, get: any) => Promise<any>;
+            };
+        };
+        options: any;
+    };
+};
+/**
+ * @param {Node} node - The DOM Node object to render
+ * @param {Object} options - Rendering options
+ * @param {Function} [options.filter] - Should return true if passed node should be included in the output
+ *          (excluding node means excluding it's children as well). Not called on the root node.
+ * @param {String} [options.bgcolor] - color for the background, any valid CSS color value.
+ * @param {Number} [options.width] - width to be applied to node before rendering.
+ * @param {Number} [options.height] - height to be applied to node before rendering.
+ * @param {Object} [options.style] - an object whose properties to be copied to node's style before rendering.
+ * @param {Number} [options.quality] - a Number between 0 and 1 indicating image quality (applicable to JPEG only), defaults to 1.0.
+ * @param {boolean} [options.escapeXhtmlForWebpack] - whether to apply fix for uglify error in dom-to-image (should be true for webpack builds), defaults to true.
+ * @param {String} [options.imagePlaceholder] - dataURL to use as a placeholder for failed images, default behaviour is to fail fast on images we can't fetch
+ * @param {Boolean} [options.cacheBust] - set to true to cache bust by appending the time to the request url
+ * @return {Promise} - A promise that is fulfilled with a SVG image data URL
+ * */
+declare function toSvg(node: any, options: any): Promise<string>;
+/**
+ * @param {Node} node - The DOM Node object to render
+ * @param {Object} options - Rendering options
+ * @return {Promise} - A promise that is fulfilled with a Uint8Array containing RGBA pixel data.
+ * */
+declare function toPixelData(node: any, options: any): Promise<any>;
+/**
+ * @param {Node} node - The DOM Node object to render
+ * @param {Object} options - Rendering options
+ * @return {Promise} - A promise that is fulfilled with a PNG image data URL
+ * */
+declare function toPng(node: any, options: any): Promise<any>;
+/**
+ * @param {Node} node - The DOM Node object to render
+ * @param {Object} options - Rendering options
+ * @return {Promise} - A promise that is fulfilled with a JPEG image data URL
+ * */
+declare function toJpeg(node: any, options: any): Promise<any>;
+/**
+ * @param {Node} node - The DOM Node object to render
+ * @param {Object} options - Rendering options
+ * @return {Promise} - A promise that is fulfilled with a PNG image blob
+ * */
+declare function toBlob(node: any, options: any): Promise<unknown>;
+export default domtoimage;