@carto/kepler.gl 0.0.1-alpha.map-libre

package/dist/components/common/color-legend.js

@@ -0,0 +1,249 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LegendRow = exports["default"] = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _reselect = require("reselect");
+
+var _d3Format = require("d3-format");
+
+var _moment = _interopRequireDefault(require("moment"));
+
+var _defaultSettings = require("../../constants/default-settings");
+
+var _filterUtils = require("../../utils/filter-utils");
+
+var _utils = require("../../utils/utils");
+
+var _templateObject;
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var ROW_H = 10;
+var GAP = 4;
+var RECT_W = 20;
+
+var StyledLegend = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  ", ";\n\n  max-height: 150px;\n  overflow-y: auto;\n\n  svg {\n    text {\n      font-size: 9px;\n      fill: ", ";\n    }\n  }\n"])), function (props) {
+  return props.theme.sidePanelScrollBar;
+}, function (props) {
+  return props.theme.textColor;
+});
+
+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);
+  };
+};
+
+var getNumericLabelFormat = function getNumericLabelFormat(domain) {
+  var diff = domain[1] - domain[0];
+
+  if (diff < 10) {
+    return (0, _d3Format.format)('.2f');
+  }
+
+  return (0, _d3Format.format)('.1f');
+};
+
+var getQuantLabelFormat = function getQuantLabelFormat(domain, fieldType) {
+  // quant scale can only be assigned to linear Fields: real, timestamp, integer
+  return fieldType === _defaultSettings.ALL_FIELD_TYPES.timestamp ? getTimeLabelFormat(domain) : !fieldType ? defaultFormat : getNumericLabelFormat(domain);
+};
+
+var getOrdinalLegends = function getOrdinalLegends(scale) {
+  var domain = scale.domain();
+  return {
+    data: domain.map(scale),
+    labels: domain
+  };
+};
+
+var getQuantLegends = function getQuantLegends(scale, labelFormat) {
+  if (typeof scale.invertExtent !== 'function') {
+    // only quantile, quantize, threshold scale has invertExtent method
+    return {
+      data: [],
+      labels: []
+    };
+  }
+
+  var labels = scale.range().map(function (d) {
+    var invert = scale.invertExtent(d);
+    return "".concat(labelFormat(invert[0]), " to ").concat(labelFormat(invert[1]));
+  });
+  return {
+    data: scale.range(),
+    labels: labels
+  };
+};
+
+var ColorLegend = /*#__PURE__*/function (_Component) {
+  (0, _inherits2["default"])(ColorLegend, _Component);
+
+  var _super = _createSuper(ColorLegend);
+
+  function ColorLegend() {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, ColorLegend);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "domainSelector", function (props) {
+      return props.domain;
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "rangeSelector", function (props) {
+      return props.range;
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "labelFormatSelector", function (props) {
+      return props.labelFormat;
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "scaleTypeSelector", function (props) {
+      return props.scaleType;
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "fieldTypeSelector", function (props) {
+      return props.fieldType;
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "legendsSelector", (0, _reselect.createSelector)(_this.domainSelector, _this.rangeSelector, _this.scaleTypeSelector, _this.labelFormatSelector, _this.fieldTypeSelector, function (domain, range, scaleType, labelFormat, fieldType) {
+      var empty = {
+        data: [],
+        labels: []
+      };
+
+      if (!range) {
+        return empty;
+      }
+
+      if ((0, _utils.isObject)(range.colorLegends)) {
+        return {
+          data: Object.keys(range.colorLegends),
+          labels: Object.values(range.colorLegends)
+        };
+      } else if (Array.isArray(range.colorMap)) {
+        return {
+          data: range.colorMap.map(function (cm) {
+            return cm[1];
+          }),
+          labels: range.colorMap.map(function (cm) {
+            return cm[0];
+          })
+        };
+      } else if (Array.isArray(range.colors)) {
+        if (!domain || !scaleType) {
+          return empty;
+        }
+
+        var scaleFunction = _defaultSettings.SCALE_FUNC[scaleType]; // color scale can only be quantize, quantile or ordinal
+        // @ts-ignore fix d3 scale
+
+        var scale = scaleFunction().domain(domain).range(range.colors);
+
+        if (scaleType === _defaultSettings.SCALE_TYPES.ordinal) {
+          return getOrdinalLegends(scale);
+        }
+
+        var formatLabel = labelFormat || getQuantLabelFormat(scale.domain(), fieldType);
+        return getQuantLegends(scale, formatLabel);
+      }
+
+      return empty;
+    }));
+    return _this;
+  }
+
+  (0, _createClass2["default"])(ColorLegend, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+          width = _this$props.width,
+          _this$props$displayLa = _this$props.displayLabel,
+          displayLabel = _this$props$displayLa === void 0 ? true : _this$props$displayLa;
+      var legends = this.legendsSelector(this.props);
+      var height = legends.data.length * (ROW_H + GAP);
+      return /*#__PURE__*/_react["default"].createElement(StyledLegend, null, /*#__PURE__*/_react["default"].createElement("svg", {
+        width: width,
+        height: height
+      }, legends.data.map(function (color, idx) {
+        return /*#__PURE__*/_react["default"].createElement(LegendRow, {
+          key: idx,
+          label: legends.labels[idx],
+          displayLabel: displayLabel,
+          color: color,
+          idx: idx
+        });
+      })));
+    }
+  }]);
+  return ColorLegend;
+}(_react.Component);
+
+exports["default"] = ColorLegend;
+(0, _defineProperty2["default"])(ColorLegend, "propTypes", {
+  width: _propTypes["default"].number.isRequired,
+  scaleType: _propTypes["default"].string,
+  domain: _propTypes["default"].oneOfType([_propTypes["default"].array, _propTypes["default"].object]),
+  fieldType: _propTypes["default"].string,
+  range: _propTypes["default"].object,
+  labelFormat: _propTypes["default"].func
+});
+
+var LegendRow = function LegendRow(_ref) {
+  var _ref$label = _ref.label,
+      label = _ref$label === void 0 ? '' : _ref$label,
+      displayLabel = _ref.displayLabel,
+      color = _ref.color,
+      idx = _ref.idx;
+  return /*#__PURE__*/_react["default"].createElement("g", {
+    transform: "translate(0, ".concat(idx * (ROW_H + GAP), ")")
+  }, /*#__PURE__*/_react["default"].createElement("rect", {
+    width: RECT_W,
+    height: ROW_H,
+    style: {
+      fill: color
+    }
+  }), /*#__PURE__*/_react["default"].createElement("text", {
+    x: RECT_W + 8,
+    y: ROW_H - 1
+  }, displayLabel ? label.toString() : ''));
+};
+
+exports.LegendRow = LegendRow;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/components/common/color-legend.js"],"names":["ROW_H","GAP","RECT_W","StyledLegend","styled","div","props","theme","sidePanelScrollBar","textColor","defaultFormat","d","getTimeLabelFormat","domain","formatter","val","moment","utc","format","getNumericLabelFormat","diff","getQuantLabelFormat","fieldType","ALL_FIELD_TYPES","timestamp","getOrdinalLegends","scale","data","map","labels","getQuantLegends","labelFormat","invertExtent","range","invert","ColorLegend","scaleType","domainSelector","rangeSelector","scaleTypeSelector","labelFormatSelector","fieldTypeSelector","empty","colorLegends","Object","keys","values","Array","isArray","colorMap","cm","colors","scaleFunction","SCALE_FUNC","SCALE_TYPES","ordinal","formatLabel","width","displayLabel","legends","legendsSelector","height","length","color","idx","Component","PropTypes","number","isRequired","string","oneOfType","array","object","func","LegendRow","label","fill","toString"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAoBA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;;;;;;;AAEA,IAAMA,KAAK,GAAG,EAAd;AACA,IAAMC,GAAG,GAAG,CAAZ;AACA,IAAMC,MAAM,GAAG,EAAf;;AAEA,IAAMC,YAAY,GAAGC,6BAAOC,GAAV,4NACd,UAAAC,KAAK;AAAA,SAAIA,KAAK,CAACC,KAAN,CAAYC,kBAAhB;AAAA,CADS,EASJ,UAAAF,KAAK;AAAA,SAAIA,KAAK,CAACC,KAAN,CAAYE,SAAhB;AAAA,CATD,CAAlB;;AAcA,IAAMC,aAAa,GAAG,SAAhBA,aAAgB,CAAAC,CAAC;AAAA,SAAIA,CAAJ;AAAA,CAAvB;;AAEA,IAAMC,kBAAkB,GAAG,SAArBA,kBAAqB,CAAAC,MAAM,EAAI;AACnC,MAAMC,SAAS,GAAG,6CAA2BD,MAA3B,CAAlB;AACA,SAAO,UAAAE,GAAG;AAAA,WAAIC,mBAAOC,GAAP,CAAWF,GAAX,EAAgBG,MAAhB,CAAuBJ,SAAvB,CAAJ;AAAA,GAAV;AACD,CAHD;;AAKA,IAAMK,qBAAqB,GAAG,SAAxBA,qBAAwB,CAAAN,MAAM,EAAI;AACtC,MAAMO,IAAI,GAAGP,MAAM,CAAC,CAAD,CAAN,GAAYA,MAAM,CAAC,CAAD,CAA/B;;AAEA,MAAIO,IAAI,GAAG,EAAX,EAAe;AACb,WAAO,sBAAO,KAAP,CAAP;AACD;;AAED,SAAO,sBAAO,KAAP,CAAP;AACD,CARD;;AAUA,IAAMC,mBAAmB,GAAG,SAAtBA,mBAAsB,CAACR,MAAD,EAASS,SAAT,EAAuB;AACjD;AACA,SAAOA,SAAS,KAAKC,iCAAgBC,SAA9B,GACHZ,kBAAkB,CAACC,MAAD,CADf,GAEH,CAACS,SAAD,GACAZ,aADA,GAEAS,qBAAqB,CAACN,MAAD,CAJzB;AAKD,CAPD;;AASA,IAAMY,iBAAiB,GAAG,SAApBA,iBAAoB,CAAAC,KAAK,EAAI;AACjC,MAAMb,MAAM,GAAGa,KAAK,CAACb,MAAN,EAAf;AACA,SAAO;AACLc,IAAAA,IAAI,EAAEd,MAAM,CAACe,GAAP,CAAWF,KAAX,CADD;AAELG,IAAAA,MAAM,EAAEhB;AAFH,GAAP;AAID,CAND;;AAQA,IAAMiB,eAAe,GAAG,SAAlBA,eAAkB,CAACJ,KAAD,EAAQK,WAAR,EAAwB;AAC9C,MAAI,OAAOL,KAAK,CAACM,YAAb,KAA8B,UAAlC,EAA8C;AAC5C;AACA,WAAO;AACLL,MAAAA,IAAI,EAAE,EADD;AAELE,MAAAA,MAAM,EAAE;AAFH,KAAP;AAID;;AAED,MAAMA,MAAM,GAAGH,KAAK,CAACO,KAAN,GAAcL,GAAd,CAAkB,UAAAjB,CAAC,EAAI;AACpC,QAAMuB,MAAM,GAAGR,KAAK,CAACM,YAAN,CAAmBrB,CAAnB,CAAf;AACA,qBAAUoB,WAAW,CAACG,MAAM,CAAC,CAAD,CAAP,CAArB,iBAAuCH,WAAW,CAACG,MAAM,CAAC,CAAD,CAAP,CAAlD;AACD,GAHc,CAAf;AAKA,SAAO;AACLP,IAAAA,IAAI,EAAED,KAAK,CAACO,KAAN,EADD;AAELJ,IAAAA,MAAM,EAANA;AAFK,GAAP;AAID,CAlBD;;IAoBqBM,W;;;;;;;;;;;;;;;uGAUF,UAAA7B,KAAK;AAAA,aAAIA,KAAK,CAACO,MAAV;AAAA,K;sGACN,UAAAP,KAAK;AAAA,aAAIA,KAAK,CAAC2B,KAAV;AAAA,K;4GACC,UAAA3B,KAAK;AAAA,aAAIA,KAAK,CAACyB,WAAV;AAAA,K;0GACP,UAAAzB,KAAK;AAAA,aAAIA,KAAK,CAAC8B,SAAV;AAAA,K;0GACL,UAAA9B,KAAK;AAAA,aAAIA,KAAK,CAACgB,SAAV;AAAA,K;wGAEP,8BAChB,MAAKe,cADW,EAEhB,MAAKC,aAFW,EAGhB,MAAKC,iBAHW,EAIhB,MAAKC,mBAJW,EAKhB,MAAKC,iBALW,EAMhB,UAAC5B,MAAD,EAASoB,KAAT,EAAgBG,SAAhB,EAA2BL,WAA3B,EAAwCT,SAAxC,EAAsD;AACpD,UAAMoB,KAAK,GAAG;AACZf,QAAAA,IAAI,EAAE,EADM;AAEZE,QAAAA,MAAM,EAAE;AAFI,OAAd;;AAIA,UAAI,CAACI,KAAL,EAAY;AACV,eAAOS,KAAP;AACD;;AACD,UAAI,qBAAST,KAAK,CAACU,YAAf,CAAJ,EAAkC;AAChC,eAAO;AACLhB,UAAAA,IAAI,EAAEiB,MAAM,CAACC,IAAP,CAAYZ,KAAK,CAACU,YAAlB,CADD;AAELd,UAAAA,MAAM,EAAEe,MAAM,CAACE,MAAP,CAAcb,KAAK,CAACU,YAApB;AAFH,SAAP;AAID,OALD,MAKO,IAAII,KAAK,CAACC,OAAN,CAAcf,KAAK,CAACgB,QAApB,CAAJ,EAAmC;AACxC,eAAO;AACLtB,UAAAA,IAAI,EAAEM,KAAK,CAACgB,QAAN,CAAerB,GAAf,CAAmB,UAAAsB,EAAE;AAAA,mBAAIA,EAAE,CAAC,CAAD,CAAN;AAAA,WAArB,CADD;AAELrB,UAAAA,MAAM,EAAEI,KAAK,CAACgB,QAAN,CAAerB,GAAf,CAAmB,UAAAsB,EAAE;AAAA,mBAAIA,EAAE,CAAC,CAAD,CAAN;AAAA,WAArB;AAFH,SAAP;AAID,OALM,MAKA,IAAIH,KAAK,CAACC,OAAN,CAAcf,KAAK,CAACkB,MAApB,CAAJ,EAAiC;AACtC,YAAI,CAACtC,MAAD,IAAW,CAACuB,SAAhB,EAA2B;AACzB,iBAAOM,KAAP;AACD;;AAED,YAAMU,aAAa,GAAGC,4BAAWjB,SAAX,CAAtB,CALsC,CAMtC;AACA;;AACA,YAAMV,KAAK,GAAG0B,aAAa,GACxBvC,MADW,CACJA,MADI,EAEXoB,KAFW,CAELA,KAAK,CAACkB,MAFD,CAAd;;AAIA,YAAIf,SAAS,KAAKkB,6BAAYC,OAA9B,EAAuC;AACrC,iBAAO9B,iBAAiB,CAACC,KAAD,CAAxB;AACD;;AAED,YAAM8B,WAAW,GAAGzB,WAAW,IAAIV,mBAAmB,CAACK,KAAK,CAACb,MAAN,EAAD,EAAiBS,SAAjB,CAAtD;AAEA,eAAOQ,eAAe,CAACJ,KAAD,EAAQ8B,WAAR,CAAtB;AACD;;AACD,aAAOd,KAAP;AACD,KA7Ce,C;;;;;;WAgDlB,kBAAS;AAAA,wBAC8B,KAAKpC,KADnC;AAAA,UACAmD,KADA,eACAA,KADA;AAAA,8CACOC,YADP;AAAA,UACOA,YADP,sCACsB,IADtB;AAGP,UAAMC,OAAO,GAAG,KAAKC,eAAL,CAAqB,KAAKtD,KAA1B,CAAhB;AACA,UAAMuD,MAAM,GAAGF,OAAO,CAAChC,IAAR,CAAamC,MAAb,IAAuB9D,KAAK,GAAGC,GAA/B,CAAf;AAEA,0BACE,gCAAC,YAAD,qBACE;AAAK,QAAA,KAAK,EAAEwD,KAAZ;AAAmB,QAAA,MAAM,EAAEI;AAA3B,SACGF,OAAO,CAAChC,IAAR,CAAaC,GAAb,CAAiB,UAACmC,KAAD,EAAQC,GAAR;AAAA,4BAChB,gCAAC,SAAD;AACE,UAAA,GAAG,EAAEA,GADP;AAEE,UAAA,KAAK,EAAEL,OAAO,CAAC9B,MAAR,CAAemC,GAAf,CAFT;AAGE,UAAA,YAAY,EAAEN,YAHhB;AAIE,UAAA,KAAK,EAAEK,KAJT;AAKE,UAAA,GAAG,EAAEC;AALP,UADgB;AAAA,OAAjB,CADH,CADF,CADF;AAeD;;;EArFsCC,gB;;;iCAApB9B,W,eACA;AACjBsB,EAAAA,KAAK,EAAES,sBAAUC,MAAV,CAAiBC,UADP;AAEjBhC,EAAAA,SAAS,EAAE8B,sBAAUG,MAFJ;AAGjBxD,EAAAA,MAAM,EAAEqD,sBAAUI,SAAV,CAAoB,CAACJ,sBAAUK,KAAX,EAAkBL,sBAAUM,MAA5B,CAApB,CAHS;AAIjBlD,EAAAA,SAAS,EAAE4C,sBAAUG,MAJJ;AAKjBpC,EAAAA,KAAK,EAAEiC,sBAAUM,MALA;AAMjBzC,EAAAA,WAAW,EAAEmC,sBAAUO;AANN,C;;AAuFd,IAAMC,SAAS,GAAG,SAAZA,SAAY;AAAA,wBAAEC,KAAF;AAAA,MAAEA,KAAF,2BAAU,EAAV;AAAA,MAAcjB,YAAd,QAAcA,YAAd;AAAA,MAA4BK,KAA5B,QAA4BA,KAA5B;AAAA,MAAmCC,GAAnC,QAAmCA,GAAnC;AAAA,sBACvB;AAAG,IAAA,SAAS,yBAAkBA,GAAG,IAAIhE,KAAK,GAAGC,GAAZ,CAArB;AAAZ,kBACE;AAAM,IAAA,KAAK,EAAEC,MAAb;AAAqB,IAAA,MAAM,EAAEF,KAA7B;AAAoC,IAAA,KAAK,EAAE;AAAC4E,MAAAA,IAAI,EAAEb;AAAP;AAA3C,IADF,eAEE;AAAM,IAAA,CAAC,EAAE7D,MAAM,GAAG,CAAlB;AAAqB,IAAA,CAAC,EAAEF,KAAK,GAAG;AAAhC,KACG0D,YAAY,GAAGiB,KAAK,CAACE,QAAN,EAAH,GAAsB,EADrC,CAFF,CADuB;AAAA,CAAlB","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 React, {Component} from 'react';\nimport PropTypes from 'prop-types';\nimport styled from 'styled-components';\nimport {createSelector} from 'reselect';\nimport {format} from 'd3-format';\nimport moment from 'moment';\nimport {SCALE_TYPES, SCALE_FUNC, ALL_FIELD_TYPES} from 'constants/default-settings';\nimport {getTimeWidgetHintFormatter} from 'utils/filter-utils';\nimport {isObject} from 'utils/utils';\n\nconst ROW_H = 10;\nconst GAP = 4;\nconst RECT_W = 20;\n\nconst StyledLegend = styled.div`\n  ${props => props.theme.sidePanelScrollBar};\n\n  max-height: 150px;\n  overflow-y: auto;\n\n  svg {\n    text {\n      font-size: 9px;\n      fill: ${props => props.theme.textColor};\n    }\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\nconst getNumericLabelFormat = domain => {\n  const diff = domain[1] - domain[0];\n\n  if (diff < 10) {\n    return format('.2f');\n  }\n\n  return format('.1f');\n};\n\nconst 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    : getNumericLabelFormat(domain);\n};\n\nconst getOrdinalLegends = scale => {\n  const domain = scale.domain();\n  return {\n    data: domain.map(scale),\n    labels: domain\n  };\n};\n\nconst getQuantLegends = (scale, labelFormat) => {\n  if (typeof scale.invertExtent !== 'function') {\n    // only quantile, quantize, threshold scale has invertExtent method\n    return {\n      data: [],\n      labels: []\n    };\n  }\n\n  const labels = scale.range().map(d => {\n    const invert = scale.invertExtent(d);\n    return `${labelFormat(invert[0])} to ${labelFormat(invert[1])}`;\n  });\n\n  return {\n    data: scale.range(),\n    labels\n  };\n};\n\nexport default class ColorLegend extends Component {\n  static propTypes = {\n    width: PropTypes.number.isRequired,\n    scaleType: PropTypes.string,\n    domain: PropTypes.oneOfType([PropTypes.array, PropTypes.object]),\n    fieldType: PropTypes.string,\n    range: PropTypes.object,\n    labelFormat: PropTypes.func\n  };\n\n  domainSelector = props => props.domain;\n  rangeSelector = props => props.range;\n  labelFormatSelector = props => props.labelFormat;\n  scaleTypeSelector = props => props.scaleType;\n  fieldTypeSelector = props => props.fieldType;\n\n  legendsSelector = createSelector(\n    this.domainSelector,\n    this.rangeSelector,\n    this.scaleTypeSelector,\n    this.labelFormatSelector,\n    this.fieldTypeSelector,\n    (domain, range, scaleType, labelFormat, fieldType) => {\n      const empty = {\n        data: [],\n        labels: []\n      };\n      if (!range) {\n        return empty;\n      }\n      if (isObject(range.colorLegends)) {\n        return {\n          data: Object.keys(range.colorLegends),\n          labels: Object.values(range.colorLegends)\n        };\n      } else if (Array.isArray(range.colorMap)) {\n        return {\n          data: range.colorMap.map(cm => cm[1]),\n          labels: range.colorMap.map(cm => cm[0])\n        };\n      } else if (Array.isArray(range.colors)) {\n        if (!domain || !scaleType) {\n          return empty;\n        }\n\n        const scaleFunction = SCALE_FUNC[scaleType];\n        // color scale can only be quantize, quantile or ordinal\n        // @ts-ignore fix d3 scale\n        const scale = scaleFunction()\n          .domain(domain)\n          .range(range.colors);\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      return empty;\n    }\n  );\n\n  render() {\n    const {width, displayLabel = true} = this.props;\n\n    const legends = this.legendsSelector(this.props);\n    const height = legends.data.length * (ROW_H + GAP);\n\n    return (\n      <StyledLegend>\n        <svg width={width} height={height}>\n          {legends.data.map((color, idx) => (\n            <LegendRow\n              key={idx}\n              label={legends.labels[idx]}\n              displayLabel={displayLabel}\n              color={color}\n              idx={idx}\n            />\n          ))}\n        </svg>\n      </StyledLegend>\n    );\n  }\n}\n\nexport const LegendRow = ({label = '', displayLabel, color, idx}) => (\n  <g transform={`translate(0, ${idx * (ROW_H + GAP)})`}>\n    <rect width={RECT_W} height={ROW_H} style={{fill: color}} />\n    <text x={RECT_W + 8} y={ROW_H - 1}>\n      {displayLabel ? label.toString() : ''}\n    </text>\n  </g>\n);\n"]}

package/dist/components/common/data-table/button.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _templateObject;
+
+var StyledButton = _styledComponents["default"].button(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  color: ", ";\n  background-color: transparent;\n  border: none;\n  cursor: pointer;\n  outline: none;\n  transition: ", ";\n  height: 2rem;\n  display: flex;\n  align-items: center;\n  padding: 0;\n\n  &:hover {\n    opacity: 0.8;\n  }\n"])), function (props) {
+  return props.theme.optionButtonColor;
+}, function (props) {
+  return props.theme.transition;
+});
+
+var noop = function noop() {};
+
+var Button = function Button(_ref) {
+  var _ref$onClick = _ref.onClick,
+      onClick = _ref$onClick === void 0 ? noop : _ref$onClick,
+      _ref$disabled = _ref.disabled,
+      disabled = _ref$disabled === void 0 ? false : _ref$disabled,
+      _ref$text = _ref.text,
+      text = _ref$text === void 0 ? '' : _ref$text,
+      children = _ref.children,
+      props = (0, _objectWithoutProperties2["default"])(_ref, ["onClick", "disabled", "text", "children"]);
+  return /*#__PURE__*/_react["default"].createElement(StyledButton, (0, _extends2["default"])({}, props, {
+    onClick: disabled ? null : onClick
+  }), text || children);
+};
+
+var _default = Button;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/components/common/data-table/canvas.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _templateObject;
+
+/*
+    ScrollSync works by getting a callback about the dom elements scroll amount
+    and then using that to pass into how much to scroll all child components,
+    it works great!
+
+    Except... Because scrolling is managed by a separate thread, and JavaScript
+    is only periodically notified of the updated position, there's some latency
+    issues with this.
+
+    We can hack around this by using a niche property of canvas that removes the
+    delay in scroll event firing! Easiest way to reproduce: enable "Trace React updates"
+    in React DevTools (it works by overlaying a viewport-wide canvas over the document).
+  */
+var _default = _styledComponents["default"].canvas(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  height: 100%;\n  left: 0;\n  pointer-events: none;\n  position: absolute;\n  top: 0;\n  width: 100%;\n"])));
+
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/components/common/data-table/cell-size.js

@@ -0,0 +1,174 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.renderedSize = renderedSize;
+exports.adjustCellsToContainer = adjustCellsToContainer;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _document = _interopRequireDefault(require("global/document"));
+
+var _dataUtils = require("../../../utils/data-utils");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var MIN_GHOST_CELL_SIZE = 200;
+/**
+ * Measure rows and column content to determine min width for each column
+ * @param {*} param0
+ */
+
+function renderedSize(_ref) {
+  var _ref$text = _ref.text,
+      dataContainer = _ref$text.dataContainer,
+      column = _ref$text.column,
+      _ref$type = _ref.type,
+      type = _ref$type === void 0 ? 'string' : _ref$type,
+      colIdx = _ref.colIdx,
+      _ref$numRowsToCalcula = _ref.numRowsToCalculate,
+      numRowsToCalculate = _ref$numRowsToCalcula === void 0 ? 10 : _ref$numRowsToCalcula,
+      _ref$fontSize = _ref.fontSize,
+      fontSize = _ref$fontSize === void 0 ? 12 : _ref$fontSize,
+      _ref$font = _ref.font,
+      font = _ref$font === void 0 ? 'Lato' : _ref$font,
+      _ref$cellPadding = _ref.cellPadding,
+      cellPadding = _ref$cellPadding === void 0 ? 40 : _ref$cellPadding,
+      _ref$maxCellSize = _ref.maxCellSize,
+      maxCellSize = _ref$maxCellSize === void 0 ? 400 : _ref$maxCellSize,
+      _ref$maxHeaderSize = _ref.maxHeaderSize,
+      maxHeaderSize = _ref$maxHeaderSize === void 0 ? 150 : _ref$maxHeaderSize,
+      _ref$minCellSize = _ref.minCellSize,
+      minCellSize = _ref$minCellSize === void 0 ? 45 : _ref$minCellSize,
+      _ref$optionsButton = _ref.optionsButton,
+      optionsButton = _ref$optionsButton === void 0 ? 30 : _ref$optionsButton;
+
+  if (!_document["default"]) {
+    return {
+      row: 0,
+      header: 0
+    };
+  }
+
+  var textCanvas = _document["default"].createElement('canvas');
+
+  _document["default"].body.appendChild(textCanvas);
+
+  var context = textCanvas.getContext('2d');
+  context.font = [fontSize, font].join('px ');
+  var rowsToSample = (0, _toConsumableArray2["default"])(Array(numRowsToCalculate)).map(function () {
+    return Math.floor(Math.random() * (dataContainer.numRows() - 1));
+  }); // If we have less than 10 rows, lets measure all of them
+
+  if (dataContainer.numRows() <= numRowsToCalculate) {
+    rowsToSample = Array.from(Array(dataContainer.numRows()).keys());
+  }
+
+  var rowWidth = Math.max.apply(Math, (0, _toConsumableArray2["default"])(rowsToSample.map(function (rowIdx) {
+    return Math.ceil(context.measureText((0, _dataUtils.parseFieldValue)(dataContainer.valueAt(rowIdx, colIdx), type)).width) + cellPadding;
+  }))); // header cell only has left padding
+
+  var headerWidth = Math.ceil(context.measureText(column).width) + cellPadding / 2 + optionsButton;
+  var minRowWidth = minCellSize + cellPadding;
+  var minHeaderWidth = minCellSize + cellPadding / 2 + optionsButton;
+  var clampedRowWidth = clamp(minRowWidth, maxCellSize, rowWidth);
+  var clampedHeaderWidth = clamp(minHeaderWidth, maxHeaderSize, headerWidth); // cleanup
+
+  textCanvas.parentElement.removeChild(textCanvas);
+  return {
+    row: clampedRowWidth,
+    header: clampedHeaderWidth
+  };
+}
+
+function clamp(min, max, value) {
+  return Math.max(Math.min(max, value), min);
+}
+
+function getColumnOrder() {
+  var pinnedColumns = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var unpinnedColumns = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  return [].concat((0, _toConsumableArray2["default"])(pinnedColumns), (0, _toConsumableArray2["default"])(unpinnedColumns));
+}
+
+function getMinCellSize(cellSizeCache) {
+  return Object.keys(cellSizeCache).reduce(function (accu, col) {
+    return _objectSpread(_objectSpread({}, accu), {}, (0, _defineProperty2["default"])({}, col, cellSizeCache[col].row));
+  }, {});
+}
+
+function getSizeSum(sizeCache, key) {
+  return Object.keys(sizeCache).reduce(function (acc, val) {
+    return acc + (key ? sizeCache[val][key] : sizeCache[val]);
+  }, 0);
+}
+/**
+ * Expand cell to fit both row and header, if there is still room left,
+ * expand last cell to fit the entire width of the container
+ * @param {object} cellSizeCache
+ * @param {string[]} columnOrder
+ * @param {number} containerWidth
+ * @param {number} roomToFill
+ */
+
+
+function expandCellSize(cellSizeCache, columnOrder, containerWidth, roomToFill) {
+  var remaining = roomToFill;
+  var expandedCellSize = columnOrder.reduce(function (accu, col) {
+    var size = cellSizeCache[col].row;
+
+    if (cellSizeCache[col].row < cellSizeCache[col].header && remaining > 0) {
+      // if we are cutting off the header, expand to fit it
+      size = cellSizeCache[col].header - cellSizeCache[col].row < remaining ? cellSizeCache[col].header : cellSizeCache[col].row + remaining;
+      remaining -= size - cellSizeCache[col].row;
+    }
+
+    return _objectSpread(_objectSpread({}, accu), {}, (0, _defineProperty2["default"])({}, col, size));
+  }, {});
+  var ghost = null;
+
+  if (remaining > 0 && remaining < MIN_GHOST_CELL_SIZE) {
+    // expand last cell
+    var lastCell = columnOrder[columnOrder.length - 1];
+    expandedCellSize[lastCell] += remaining;
+  } else if (remaining >= MIN_GHOST_CELL_SIZE) {
+    // if too much left add a ghost cell
+    ghost = remaining;
+  }
+
+  return {
+    cellSizeCache: expandedCellSize,
+    ghost: ghost
+  };
+}
+/**
+ * Adjust cell size based on container width
+ * @param {number} containerWidth
+ * @param {Object} cellSizeCache
+ * @param {string[]} pinnedColumns
+ * @param {string[]} unpinnedColumns
+ */
+
+
+function adjustCellsToContainer(containerWidth, cellSizeCache, pinnedColumns, unpinnedColumns) {
+  var minRowSum = getSizeSum(cellSizeCache, 'row');
+
+  if (minRowSum >= containerWidth) {
+    // we apply the min Width to all cells
+    return {
+      cellSizeCache: getMinCellSize(cellSizeCache)
+    };
+  } // if we have some room to expand
+
+
+  var columnOrder = getColumnOrder(pinnedColumns, unpinnedColumns);
+  return expandCellSize(cellSizeCache, columnOrder, containerWidth, containerWidth - minRowSum);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/components/common/data-table/cell-size.js"],"names":["MIN_GHOST_CELL_SIZE","renderedSize","text","dataContainer","column","type","colIdx","numRowsToCalculate","fontSize","font","cellPadding","maxCellSize","maxHeaderSize","minCellSize","optionsButton","document","row","header","textCanvas","createElement","body","appendChild","context","getContext","join","rowsToSample","Array","map","Math","floor","random","numRows","from","keys","rowWidth","max","rowIdx","ceil","measureText","valueAt","width","headerWidth","minRowWidth","minHeaderWidth","clampedRowWidth","clamp","clampedHeaderWidth","parentElement","removeChild","min","value","getColumnOrder","pinnedColumns","unpinnedColumns","getMinCellSize","cellSizeCache","Object","reduce","accu","col","getSizeSum","sizeCache","key","acc","val","expandCellSize","columnOrder","containerWidth","roomToFill","remaining","expandedCellSize","size","ghost","lastCell","length","adjustCellsToContainer","minRowSum"],"mappings":"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","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 document from 'global/document';\nimport {parseFieldValue} from 'utils/data-utils';\n\nconst MIN_GHOST_CELL_SIZE = 200;\n\n/**\n * Measure rows and column content to determine min width for each column\n * @param {*} param0\n */\nexport function renderedSize({\n  text: {dataContainer, column},\n  type = 'string',\n  colIdx,\n  numRowsToCalculate = 10,\n  fontSize = 12,\n  font = 'Lato',\n  cellPadding = 40,\n  maxCellSize = 400,\n  maxHeaderSize = 150,\n  minCellSize = 45,\n  optionsButton = 30\n}) {\n  if (!document) {\n    return {\n      row: 0,\n      header: 0\n    };\n  }\n  const textCanvas = document.createElement('canvas');\n  document.body.appendChild(textCanvas);\n  const context = textCanvas.getContext('2d');\n  context.font = [fontSize, font].join('px ');\n\n  let rowsToSample = [...Array(numRowsToCalculate)].map(() =>\n    Math.floor(Math.random() * (dataContainer.numRows() - 1))\n  );\n\n  // If we have less than 10 rows, lets measure all of them\n  if (dataContainer.numRows() <= numRowsToCalculate) {\n    rowsToSample = Array.from(Array(dataContainer.numRows()).keys());\n  }\n  const rowWidth = Math.max(\n    ...rowsToSample.map(\n      rowIdx =>\n        Math.ceil(\n          context.measureText(parseFieldValue(dataContainer.valueAt(rowIdx, colIdx), type)).width\n        ) + cellPadding\n    )\n  );\n  // header cell only has left padding\n  const headerWidth =\n    Math.ceil(context.measureText(column).width) + cellPadding / 2 + optionsButton;\n\n  const minRowWidth = minCellSize + cellPadding;\n  const minHeaderWidth = minCellSize + cellPadding / 2 + optionsButton;\n\n  const clampedRowWidth = clamp(minRowWidth, maxCellSize, rowWidth);\n  const clampedHeaderWidth = clamp(minHeaderWidth, maxHeaderSize, headerWidth);\n\n  // cleanup\n  textCanvas.parentElement.removeChild(textCanvas);\n\n  return {\n    row: clampedRowWidth,\n    header: clampedHeaderWidth\n  };\n}\n\nfunction clamp(min, max, value) {\n  return Math.max(Math.min(max, value), min);\n}\n\nfunction getColumnOrder(pinnedColumns = [], unpinnedColumns = []) {\n  return [...pinnedColumns, ...unpinnedColumns];\n}\n\nfunction getMinCellSize(cellSizeCache) {\n  return Object.keys(cellSizeCache).reduce(\n    (accu, col) => ({\n      ...accu,\n      [col]: cellSizeCache[col].row\n    }),\n    {}\n  );\n}\n\nfunction getSizeSum(sizeCache, key) {\n  return Object.keys(sizeCache).reduce(\n    (acc, val) => acc + (key ? sizeCache[val][key] : sizeCache[val]),\n    0\n  );\n}\n\n/**\n * Expand cell to fit both row and header, if there is still room left,\n * expand last cell to fit the entire width of the container\n * @param {object} cellSizeCache\n * @param {string[]} columnOrder\n * @param {number} containerWidth\n * @param {number} roomToFill\n */\nfunction expandCellSize(cellSizeCache, columnOrder, containerWidth, roomToFill) {\n  let remaining = roomToFill;\n\n  const expandedCellSize = columnOrder.reduce((accu, col) => {\n    let size = cellSizeCache[col].row;\n    if (cellSizeCache[col].row < cellSizeCache[col].header && remaining > 0) {\n      // if we are cutting off the header, expand to fit it\n      size =\n        cellSizeCache[col].header - cellSizeCache[col].row < remaining\n          ? cellSizeCache[col].header\n          : cellSizeCache[col].row + remaining;\n      remaining -= size - cellSizeCache[col].row;\n    }\n\n    return {\n      ...accu,\n      [col]: size\n    };\n  }, {});\n\n  let ghost = null;\n  if (remaining > 0 && remaining < MIN_GHOST_CELL_SIZE) {\n    // expand last cell\n    const lastCell = columnOrder[columnOrder.length - 1];\n    expandedCellSize[lastCell] += remaining;\n  } else if (remaining >= MIN_GHOST_CELL_SIZE) {\n    // if too much left add a ghost cell\n    ghost = remaining;\n  }\n\n  return {\n    cellSizeCache: expandedCellSize,\n    ghost\n  };\n}\n\n/**\n * Adjust cell size based on container width\n * @param {number} containerWidth\n * @param {Object} cellSizeCache\n * @param {string[]} pinnedColumns\n * @param {string[]} unpinnedColumns\n */\nexport function adjustCellsToContainer(\n  containerWidth,\n  cellSizeCache,\n  pinnedColumns,\n  unpinnedColumns\n) {\n  const minRowSum = getSizeSum(cellSizeCache, 'row');\n  if (minRowSum >= containerWidth) {\n    // we apply the min Width to all cells\n    return {cellSizeCache: getMinCellSize(cellSizeCache)};\n  }\n\n  // if we have some room to expand\n  const columnOrder = getColumnOrder(pinnedColumns, unpinnedColumns);\n  return expandCellSize(cellSizeCache, columnOrder, containerWidth, containerWidth - minRowSum);\n}\n"]}