@carto/kepler.gl 0.1.0-alpha.0 → 0.1.0-next.0

package/dist/utils/color-utils.js

@@ -0,0 +1,144 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.checkColorOrFallback = checkColorOrFallback;
+exports.createLinearGradient = createLinearGradient;
+exports.getColorGroupByName = getColorGroupByName;
+exports.hexToRgb = hexToRgb;
+exports.isHexColor = isHexColor;
+exports.isRgbColor = isRgbColor;
+exports.reverseColorRange = reverseColorRange;
+exports.rgbToHex = rgbToHex;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _defaultSettings = require("../constants/default-settings");
+var _d3Color = require("d3-color");
+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; } // Copyright (c) 2022 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.
+/**
+ * get r g b from hex code
+ *
+ * @param hex
+ * @returns array of r g bs
+ */
+function hexToRgb(hex) {
+  var result = isHexColor(hex);
+  if (!result) {
+    return [0, 0, 0];
+  }
+  var r = parseInt(result[1], 16);
+  var g = parseInt(result[2], 16);
+  var b = parseInt(result[3], 16);
+  return [r, g, b];
+}
+function isHexColor(hex) {
+  var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+  return result;
+}
+function PadNum(c) {
+  var hex = c.toString(16);
+  return hex.length === 1 ? "0".concat(hex) : hex;
+}
+
+/**
+ * get hex from r g b
+ *
+ * @param rgb
+ * @returns hex string
+ */
+function rgbToHex(_ref) {
+  var _ref2 = (0, _slicedToArray2["default"])(_ref, 3),
+    r = _ref2[0],
+    g = _ref2[1],
+    b = _ref2[2];
+  return "#".concat([r, g, b].map(function (n) {
+    return PadNum(n);
+  }).join('')).toUpperCase();
+}
+
+/**
+ * Get color group name by parsing name, discard step in the name
+ * e.g. Global Warming 6 -> Global Warming
+ *
+ * @param {Object} colorRange
+ * @return {string | null}
+ */
+function getColorGroupByName(colorRange) {
+  if (!colorRange || typeof colorRange.name !== 'string') {
+    return null;
+  }
+  return colorRange.name.replace(/\b[^a-zA-Z]+$/, '');
+}
+
+/**
+ * Get a reversed colorRange
+ * @param reversed
+ * @param colorRange
+ */
+function reverseColorRange(reversed, colorRange) {
+  if (!colorRange) return null;
+  // if (colorRange.reversed) return colorRange;
+  return _objectSpread(_objectSpread({}, colorRange), {}, {
+    reversed: reversed,
+    colors: colorRange.colors.slice().reverse()
+  });
+}
+
+/**
+ * given a list of rgb arrays it will generate a linear gradient css rule
+ * @param direction
+ * @param colors
+ * @return
+ */
+function createLinearGradient(direction, colors) {
+  var step = parseFloat((100.0 / colors.length).toFixed(2));
+  var bands = colors.map(function (rgb, index) {
+    return "rgba(".concat(rgb.join(','), ", 1) ").concat(step * index, "%, rgba(").concat(rgb.join(','), ", 1) ").concat(step * (index + 1), "%");
+  });
+  return "linear-gradient(to ".concat(direction, ", ").concat(bands.join(','), ")");
+}
+
+/**
+ * Whether color is rgb
+ * @returns
+ */
+function isRgbColor(color) {
+  if (color && Array.isArray(color) && color.length === 3 && color.every(function (n) {
+    return Number.isFinite(n) && n <= 255 && n >= 0;
+  })) {
+    return true;
+  }
+  return false;
+}
+function checkColorOrFallback(hexColor) {
+  var fallback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _defaultSettings.UNKNOWN_COLOR;
+  var color = (0, _d3Color.rgb)(hexColor);
+  var r = color.r,
+    g = color.g,
+    b = color.b;
+  // @ts-expect-error
+  return [r, g, b].some(isNaN) ? _d3Color.rgb.apply(void 0, (0, _toConsumableArray2["default"])(fallback)).formatHex() : hexColor;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_defaultSettings","require","_d3Color","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","hexToRgb","hex","result","isHexColor","parseInt","g","b","exec","PadNum","c","toString","concat","rgbToHex","_ref","_ref2","_slicedToArray2","map","n","join","toUpperCase","getColorGroupByName","colorRange","name","replace","reverseColorRange","reversed","colors","slice","reverse","createLinearGradient","direction","step","parseFloat","toFixed","bands","rgb","index","isRgbColor","color","Array","isArray","every","Number","isFinite","checkColorOrFallback","hexColor","fallback","undefined","UNKNOWN_COLOR","d3Rgb","some","isNaN","_toConsumableArray2","formatHex"],"sources":["../../src/utils/color-utils.ts"],"sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {ColorRange} from 'constants/color-ranges';\nimport {HexColor, RGBColor} from 'reducers';\nimport {UNKNOWN_COLOR} from 'constants/default-settings';\nimport {rgb as d3Rgb} from 'd3-color';\n\n/**\n * get r g b from hex code\n *\n * @param hex\n * @returns array of r g bs\n */\nexport function hexToRgb(hex: string): RGBColor {\n  const result = isHexColor(hex);\n\n  if (!result) {\n    return [0, 0, 0];\n  }\n\n  const r = parseInt(result[1], 16);\n  const g = parseInt(result[2], 16);\n  const b = parseInt(result[3], 16);\n\n  return [r, g, b];\n}\n\nexport function isHexColor(hex: string): RegExpExecArray | null {\n  const result = /^#?([a-f\\d]{2})([a-f\\d]{2})([a-f\\d]{2})$/i.exec(hex);\n\n  return result;\n}\n\nfunction PadNum(c) {\n  const hex = c.toString(16);\n  return hex.length === 1 ? `0${hex}` : hex;\n}\n\n/**\n * get hex from r g b\n *\n * @param rgb\n * @returns hex string\n */\nexport function rgbToHex([r, g, b]: RGBColor): HexColor {\n  return `#${[r, g, b].map(n => PadNum(n)).join('')}`.toUpperCase();\n}\n\n/**\n * Get color group name by parsing name, discard step in the name\n * e.g. Global Warming 6 -> Global Warming\n *\n * @param {Object} colorRange\n * @return {string | null}\n */\nexport function getColorGroupByName(colorRange: ColorRange): string | null {\n  if (!colorRange || typeof colorRange.name !== 'string') {\n    return null;\n  }\n\n  return colorRange.name.replace(/\\b[^a-zA-Z]+$/, '');\n}\n\n/**\n * Get a reversed colorRange\n * @param reversed\n * @param colorRange\n */\nexport function reverseColorRange(reversed: boolean, colorRange: ColorRange): ColorRange | null {\n  if (!colorRange) return null;\n  // if (colorRange.reversed) return colorRange;\n  return {\n    ...colorRange,\n    reversed,\n    colors: colorRange.colors.slice().reverse()\n  };\n}\n\n/**\n * given a list of rgb arrays it will generate a linear gradient css rule\n * @param direction\n * @param colors\n * @return\n */\nexport function createLinearGradient(direction: string, colors: RGBColor[]) {\n  const step = parseFloat((100.0 / colors.length).toFixed(2));\n  const bands = colors.map((rgb, index) => {\n    return `rgba(${rgb.join(',')}, 1) ${step * index}%, rgba(${rgb.join(',')}, 1) ${step *\n      (index + 1)}%`;\n  });\n\n  return `linear-gradient(to ${direction}, ${bands.join(',')})`;\n}\n\n/**\n * Whether color is rgb\n * @returns\n */\nexport function isRgbColor(color: unknown): color is RGBColor {\n  if (\n    color &&\n    Array.isArray(color) &&\n    color.length === 3 &&\n    color.every(n => Number.isFinite(n) && n <= 255 && n >= 0)\n  ) {\n    return true;\n  }\n  return false;\n}\n\nexport function checkColorOrFallback(hexColor, fallback = UNKNOWN_COLOR) {\n  const color = d3Rgb(hexColor);\n  const {r, g, b} = color;\n  // @ts-expect-error\n  return [r, g, b].some(isNaN) ? d3Rgb(...fallback).formatHex() : hexColor;\n}\n\n"],"mappings":";;;;;;;;;;;;;;;;;AAsBA,IAAAA,gBAAA,GAAAC,OAAA;AACA,IAAAC,QAAA,GAAAD,OAAA;AAAsC,SAAAE,QAAAC,CAAA,EAAAC,CAAA,QAAAC,CAAA,GAAAC,MAAA,CAAAC,IAAA,CAAAJ,CAAA,OAAAG,MAAA,CAAAE,qBAAA,QAAAC,CAAA,GAAAH,MAAA,CAAAE,qBAAA,CAAAL,CAAA,GAAAC,CAAA,KAAAK,CAAA,GAAAA,CAAA,CAAAC,MAAA,WAAAN,CAAA,WAAAE,MAAA,CAAAK,wBAAA,CAAAR,CAAA,EAAAC,CAAA,EAAAQ,UAAA,OAAAP,CAAA,CAAAQ,IAAA,CAAAC,KAAA,CAAAT,CAAA,EAAAI,CAAA,YAAAJ,CAAA;AAAA,SAAAU,cAAAZ,CAAA,aAAAC,CAAA,MAAAA,CAAA,GAAAY,SAAA,CAAAC,MAAA,EAAAb,CAAA,UAAAC,CAAA,WAAAW,SAAA,CAAAZ,CAAA,IAAAY,SAAA,CAAAZ,CAAA,QAAAA,CAAA,OAAAF,OAAA,CAAAI,MAAA,CAAAD,CAAA,OAAAa,OAAA,WAAAd,CAAA,QAAAe,gBAAA,aAAAhB,CAAA,EAAAC,CAAA,EAAAC,CAAA,CAAAD,CAAA,SAAAE,MAAA,CAAAc,yBAAA,GAAAd,MAAA,CAAAe,gBAAA,CAAAlB,CAAA,EAAAG,MAAA,CAAAc,yBAAA,CAAAf,CAAA,KAAAH,OAAA,CAAAI,MAAA,CAAAD,CAAA,GAAAa,OAAA,WAAAd,CAAA,IAAAE,MAAA,CAAAgB,cAAA,CAAAnB,CAAA,EAAAC,CAAA,EAAAE,MAAA,CAAAK,wBAAA,CAAAN,CAAA,EAAAD,CAAA,iBAAAD,CAAA,IAvBtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAOA;AACA;AACA;AACA;AACA;AACA;AACO,SAASoB,QAAQA,CAACC,GAAW,EAAY;EAC9C,IAAMC,MAAM,GAAGC,UAAU,CAACF,GAAG,CAAC;EAE9B,IAAI,CAACC,MAAM,EAAE;IACX,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;EAClB;EAEA,IAAMrB,CAAC,GAAGuB,QAAQ,CAACF,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;EACjC,IAAMG,CAAC,GAAGD,QAAQ,CAACF,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;EACjC,IAAMI,CAAC,GAAGF,QAAQ,CAACF,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;EAEjC,OAAO,CAACrB,CAAC,EAAEwB,CAAC,EAAEC,CAAC,CAAC;AAClB;AAEO,SAASH,UAAUA,CAACF,GAAW,EAA0B;EAC9D,IAAMC,MAAM,GAAG,2CAA2C,CAACK,IAAI,CAACN,GAAG,CAAC;EAEpE,OAAOC,MAAM;AACf;AAEA,SAASM,MAAMA,CAACC,CAAC,EAAE;EACjB,IAAMR,GAAG,GAAGQ,CAAC,CAACC,QAAQ,CAAC,EAAE,CAAC;EAC1B,OAAOT,GAAG,CAACP,MAAM,KAAK,CAAC,OAAAiB,MAAA,CAAOV,GAAG,IAAKA,GAAG;AAC3C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACO,SAASW,QAAQA,CAAAC,IAAA,EAAgC;EAAA,IAAAC,KAAA,OAAAC,eAAA,aAAAF,IAAA;IAA9BhC,CAAC,GAAAiC,KAAA;IAAET,CAAC,GAAAS,KAAA;IAAER,CAAC,GAAAQ,KAAA;EAC/B,OAAO,IAAAH,MAAA,CAAI,CAAC9B,CAAC,EAAEwB,CAAC,EAAEC,CAAC,CAAC,CAACU,GAAG,CAAC,UAAAC,CAAC;IAAA,OAAIT,MAAM,CAACS,CAAC,CAAC;EAAA,EAAC,CAACC,IAAI,CAAC,EAAE,CAAC,EAAGC,WAAW,CAAC,CAAC;AACnE;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,mBAAmBA,CAACC,UAAsB,EAAiB;EACzE,IAAI,CAACA,UAAU,IAAI,OAAOA,UAAU,CAACC,IAAI,KAAK,QAAQ,EAAE;IACtD,OAAO,IAAI;EACb;EAEA,OAAOD,UAAU,CAACC,IAAI,CAACC,OAAO,CAAC,eAAe,EAAE,EAAE,CAAC;AACrD;;AAEA;AACA;AACA;AACA;AACA;AACO,SAASC,iBAAiBA,CAACC,QAAiB,EAAEJ,UAAsB,EAAqB;EAC9F,IAAI,CAACA,UAAU,EAAE,OAAO,IAAI;EAC5B;EACA,OAAA7B,aAAA,CAAAA,aAAA,KACK6B,UAAU;IACbI,QAAQ,EAARA,QAAQ;IACRC,MAAM,EAAEL,UAAU,CAACK,MAAM,CAACC,KAAK,CAAC,CAAC,CAACC,OAAO,CAAC;EAAC;AAE/C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,oBAAoBA,CAACC,SAAiB,EAAEJ,MAAkB,EAAE;EAC1E,IAAMK,IAAI,GAAGC,UAAU,CAAC,CAAC,KAAK,GAAGN,MAAM,CAAChC,MAAM,EAAEuC,OAAO,CAAC,CAAC,CAAC,CAAC;EAC3D,IAAMC,KAAK,GAAGR,MAAM,CAACV,GAAG,CAAC,UAACmB,GAAG,EAAEC,KAAK,EAAK;IACvC,eAAAzB,MAAA,CAAewB,GAAG,CAACjB,IAAI,CAAC,GAAG,CAAC,WAAAP,MAAA,CAAQoB,IAAI,GAAGK,KAAK,cAAAzB,MAAA,CAAWwB,GAAG,CAACjB,IAAI,CAAC,GAAG,CAAC,WAAAP,MAAA,CAAQoB,IAAI,IACjFK,KAAK,GAAG,CAAC,CAAC;EACf,CAAC,CAAC;EAEF,6BAAAzB,MAAA,CAA6BmB,SAAS,QAAAnB,MAAA,CAAKuB,KAAK,CAAChB,IAAI,CAAC,GAAG,CAAC;AAC5D;;AAEA;AACA;AACA;AACA;AACO,SAASmB,UAAUA,CAACC,KAAc,EAAqB;EAC5D,IACEA,KAAK,IACLC,KAAK,CAACC,OAAO,CAACF,KAAK,CAAC,IACpBA,KAAK,CAAC5C,MAAM,KAAK,CAAC,IAClB4C,KAAK,CAACG,KAAK,CAAC,UAAAxB,CAAC;IAAA,OAAIyB,MAAM,CAACC,QAAQ,CAAC1B,CAAC,CAAC,IAAIA,CAAC,IAAI,GAAG,IAAIA,CAAC,IAAI,CAAC;EAAA,EAAC,EAC1D;IACA,OAAO,IAAI;EACb;EACA,OAAO,KAAK;AACd;AAEO,SAAS2B,oBAAoBA,CAACC,QAAQ,EAA4B;EAAA,IAA1BC,QAAQ,GAAArD,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAsD,SAAA,GAAAtD,SAAA,MAAGuD,8BAAa;EACrE,IAAMV,KAAK,GAAG,IAAAW,YAAK,EAACJ,QAAQ,CAAC;EAC7B,IAAOhE,CAAC,GAAUyD,KAAK,CAAhBzD,CAAC;IAAEwB,CAAC,GAAOiC,KAAK,CAAbjC,CAAC;IAAEC,CAAC,GAAIgC,KAAK,CAAVhC,CAAC;EACd;EACA,OAAO,CAACzB,CAAC,EAAEwB,CAAC,EAAEC,CAAC,CAAC,CAAC4C,IAAI,CAACC,KAAK,CAAC,GAAGF,YAAK,CAAA1D,KAAA,aAAA6D,mBAAA,aAAIN,QAAQ,EAAC,CAACO,SAAS,CAAC,CAAC,GAAGR,QAAQ;AAC1E","ignoreList":[]}

package/dist/utils/custom-scales.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.scaleIdentity = scaleIdentity;
+function scaleIdentity() {
+  var unknown;
+  function scale(x) {
+    return x === null ? unknown : x;
+  }
+  scale.invert = scale;
+  scale.domain = scale.range = scaleIdentity;
+  scale.unknown = function (u) {
+    if (u) {
+      unknown = u;
+    }
+    return scale;
+  };
+  return scale;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJzY2FsZUlkZW50aXR5IiwidW5rbm93biIsInNjYWxlIiwieCIsImludmVydCIsImRvbWFpbiIsInJhbmdlIiwidSJdLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9jdXN0b20tc2NhbGVzLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBmdW5jdGlvbiBzY2FsZUlkZW50aXR5KCkge1xuICBsZXQgdW5rbm93bjtcbiAgZnVuY3Rpb24gc2NhbGUoeCkge1xuICAgIHJldHVybiB4ID09PSBudWxsID8gdW5rbm93biA6IHg7XG4gIH1cblxuICBzY2FsZS5pbnZlcnQgPSBzY2FsZTtcblxuICBzY2FsZS5kb21haW4gPSBzY2FsZS5yYW5nZSA9IHNjYWxlSWRlbnRpdHk7XG5cbiAgc2NhbGUudW5rbm93biA9IHUgPT4ge1xuICAgIGlmICh1KSB7XG4gICAgICB1bmtub3duID0gdTtcbiAgICB9XG5cbiAgICByZXR1cm4gc2NhbGU7XG4gIH07XG5cbiAgcmV0dXJuIHNjYWxlO1xufVxuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBTyxTQUFTQSxhQUFhQSxDQUFBLEVBQUc7RUFDOUIsSUFBSUMsT0FBTztFQUNYLFNBQVNDLEtBQUtBLENBQUNDLENBQUMsRUFBRTtJQUNoQixPQUFPQSxDQUFDLEtBQUssSUFBSSxHQUFHRixPQUFPLEdBQUdFLENBQUM7RUFDakM7RUFFQUQsS0FBSyxDQUFDRSxNQUFNLEdBQUdGLEtBQUs7RUFFcEJBLEtBQUssQ0FBQ0csTUFBTSxHQUFHSCxLQUFLLENBQUNJLEtBQUssR0FBR04sYUFBYTtFQUUxQ0UsS0FBSyxDQUFDRCxPQUFPLEdBQUcsVUFBQU0sQ0FBQyxFQUFJO0lBQ25CLElBQUlBLENBQUMsRUFBRTtNQUNMTixPQUFPLEdBQUdNLENBQUM7SUFDYjtJQUVBLE9BQU9MLEtBQUs7RUFDZCxDQUFDO0VBRUQsT0FBT0EsS0FBSztBQUNkIiwiaWdub3JlTGlzdCI6W119

package/dist/utils/data-scale-utils.d.ts

@@ -1,23 +1,23 @@
-import { DataContainerInterface } from './table-utils/data-container-interface';
-type dataValueAccessor = <T>(param: T) => T;
-type dataContainerValueAccessor = (d: {
-    index: number;
-}, dc: DataContainerInterface) => any;
-type sort = (a: any, b: any) => any;
-/**
- * return quantile domain for an array of data
- */
-export declare function getQuantileDomain(data: any[], valueAccessor?: dataValueAccessor, sortFunc?: sort): number[];
-/**
- * return ordinal domain for a data container
- */
-export declare function getOrdinalDomain(dataContainer: DataContainerInterface, valueAccessor: dataContainerValueAccessor): string[];
-/**
- * return linear domain for an array of data
- */
-export declare function getLinearDomain(data: number[], valueAccessor?: dataValueAccessor): [number, number];
-/**
- * return linear domain for an array of data. A log scale domain cannot contain 0
- */
-export declare function getLogDomain(data: any[], valueAccessor: dataValueAccessor): [number, number];
-export {};
+import { DataContainerInterface } from './table-utils/data-container-interface';
+type dataValueAccessor = <T>(param: T) => T;
+type dataContainerValueAccessor = (d: {
+    index: number;
+}, dc: DataContainerInterface) => any;
+type sort = (a: any, b: any) => any;
+/**
+ * return quantile domain for an array of data
+ */
+export declare function getQuantileDomain(data: any[], valueAccessor?: dataValueAccessor, sortFunc?: sort): number[];
+/**
+ * return ordinal domain for a data container
+ */
+export declare function getOrdinalDomain(dataContainer: DataContainerInterface, valueAccessor: dataContainerValueAccessor): string[];
+/**
+ * return linear domain for an array of data
+ */
+export declare function getLinearDomain(data: number[], valueAccessor?: dataValueAccessor): [number, number];
+/**
+ * return linear domain for an array of data. A log scale domain cannot contain 0
+ */
+export declare function getLogDomain(data: any[], valueAccessor: dataValueAccessor): [number, number];
+export {};

package/dist/utils/data-scale-utils.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getLinearDomain = getLinearDomain;
+exports.getLogDomain = getLogDomain;
+exports.getOrdinalDomain = getOrdinalDomain;
+exports.getQuantileDomain = getQuantileDomain;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _dataUtils = require("./data-utils");
+var _d3Array = require("d3-array");
+// Copyright (c) 2022 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.
+
+/**
+ * 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(_dataUtils.notNullorUndefined).sort(sortFunc);
+}
+
+/**
+ * return ordinal domain for a data container
+ */
+function getOrdinalDomain(dataContainer, valueAccessor) {
+  var values = dataContainer.mapIndex(valueAccessor);
+  return (0, _dataUtils.uniqueSortedByFrequency)(values);
+}
+
+/**
+ * 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];
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/utils/data-utils.d.ts

@@ -1,115 +1,115 @@
-import { Millisecond } from 'reducers/types';
-import { Layer } from 'layers';
-import { Bounds } from 'reducers/map-state-updaters';
-import { DataContainerInterface } from './table-utils/data-container-interface';
-import { Field } from './table-utils/kepler-table';
-export 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 uniqueSortedByFrequency<T>(values: T[]): string[];
-/**
- * return center of map from given points
- * @param layers
- * @returns coordinates of map center, empty if not found
- */
-export declare function findMapBounds(layers: Layer[]): Bounds | null;
-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, format?: string): Millisecond | null;
-export declare function maybeToDate(isTime: boolean, fieldIdx: number, format: string, dc: DataContainerInterface, d: {
-    index: number;
-}): any;
-/**
- * whether null or undefined
- */
-export declare function notNullorUndefined<T extends NonNullable<any>>(d: T | null | undefined): d is T;
-/**
- * Whether d is a number, this filtered out NaN as well
- */
-export declare function isNumber(d: any): boolean;
-/**
- * whether null or undefined
- */
-export declare function isPlainObject(obj: any): boolean;
-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;
-/**
- * get number of decimals to round to for slider from step
- * @param step
- * @returns- number of decimal
- */
-export declare function getRoundingDecimalFromStep(step: number): number;
-/**
- * Use in slider, given a number and an array of numbers, return the nears number from the array
- * @param value
- * @param marks
- */
-export declare function snapToMarks(value: number, marks: 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[]): 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 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;
-/**
- *
- * @param array
- * @param from
- * @param to
- */
-export declare const arrayMove: <T>(array: T[], from: number, to: number) => T[];
-/**
- * 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>, field?: Field): FieldFormatter;
-export declare function applyDefaultFormat(tooltipFormat: any): any;
-export declare function getBooleanFormatter(format: string): FieldFormatter;
-export declare function applyCustomFormat(format: any, field: any): FieldFormatter;
-/**
- * Format epoch milliseconds with a format string
- * @type timezone
- */
-export declare function datetimeFormatter(timezone?: string | null): (format?: string) => (ts: number) => string;
-export declare function uniqueSortedPairByFrequency(values: any): {
-    left: any;
-    right: any;
-}[];
+import { Millisecond } from 'reducers/types';
+import { Layer } from 'layers';
+import { Bounds } from 'reducers/map-state-updaters';
+import { DataContainerInterface } from './table-utils/data-container-interface';
+import { Field } from './table-utils/kepler-table';
+export 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 uniqueSortedByFrequency<T>(values: T[]): string[];
+/**
+ * return center of map from given points
+ * @param layers
+ * @returns coordinates of map center, empty if not found
+ */
+export declare function findMapBounds(layers: Layer[]): Bounds | null;
+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, format?: string): Millisecond | null;
+export declare function maybeToDate(isTime: boolean, fieldIdx: number, format: string, dc: DataContainerInterface, d: {
+    index: number;
+}): any;
+/**
+ * whether null or undefined
+ */
+export declare function notNullorUndefined<T extends NonNullable<any>>(d: T | null | undefined): d is T;
+/**
+ * Whether d is a number, this filtered out NaN as well
+ */
+export declare function isNumber(d: any): boolean;
+/**
+ * whether null or undefined
+ */
+export declare function isPlainObject(obj: any): boolean;
+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;
+/**
+ * get number of decimals to round to for slider from step
+ * @param step
+ * @returns- number of decimal
+ */
+export declare function getRoundingDecimalFromStep(step: number): number;
+/**
+ * Use in slider, given a number and an array of numbers, return the nears number from the array
+ * @param value
+ * @param marks
+ */
+export declare function snapToMarks(value: number, marks: 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[]): 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 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;
+/**
+ *
+ * @param array
+ * @param from
+ * @param to
+ */
+export declare const arrayMove: <T>(array: T[], from: number, to: number) => T[];
+/**
+ * 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>, field?: Field): FieldFormatter;
+export declare function applyDefaultFormat(tooltipFormat: any): any;
+export declare function getBooleanFormatter(format: string): FieldFormatter;
+export declare function applyCustomFormat(format: any, field: any): FieldFormatter;
+/**
+ * Format epoch milliseconds with a format string
+ * @type timezone
+ */
+export declare function datetimeFormatter(timezone?: string | null): (format?: string) => (ts: number) => string;
+export declare function uniqueSortedPairByFrequency(values: any): {
+    left: any;
+    right: any;
+}[];