@kepler.gl/components 3.0.0-alpha.0

package/dist/side-panel/interaction-panel/tooltip-config/tooltip-chicklet.js

@@ -0,0 +1,264 @@
+// 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.
+
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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 _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _chickletedInput = require("../../../common/item-selector/chickleted-input");
+
+var _icons = require("../../../common/icons");
+
+var _dropdownList = _interopRequireDefault(require("../../../common/item-selector/dropdown-list"));
+
+var _localization = require("@kepler.gl/localization");
+
+var _reactOnclickoutside = _interopRequireDefault(require("react-onclickoutside"));
+
+var _constants = require("@kepler.gl/constants");
+
+var _utils = require("@kepler.gl/utils");
+
+var _tippyTooltip = _interopRequireDefault(require("../../../common/tippy-tooltip"));
+
+var _templateObject, _templateObject2, _templateObject3, _templateObject4;
+
+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; } }
+
+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 TIME_DISPLAY = '2020-05-11 14:00';
+
+var getValue = function getValue(fmt) {
+  return fmt[_constants.TOOLTIP_KEY];
+};
+
+var addDTimeLabel = function addDTimeLabel(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, _utils.getFormatter)(getValue(f))(TIME_DISPLAY) : f.label
+    });
+  });
+};
+
+function getFormatLabels(fields, fieldName) {
+  var fieldType = fields.find(function (f) {
+    return f.name === fieldName;
+  }).type;
+  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 addDTimeLabel(formatLabels);
+}
+
+var ChickletAddonWrapper = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  position: relative;\n"])));
+
+var ChickletAddon = _styledComponents["default"].div(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  margin-right: 4px;\n"])));
+
+var StyledPopover = _styledComponents["default"].div(_templateObject3 || (_templateObject3 = (0, _taggedTemplateLiteral2["default"])(["\n  margin-left: -64px;\n  position: absolute;\n  top: 20px;\n  width: 140px;\n  z-index: 101;\n"])));
+
+var hashStyles = {
+  SHOW: 'SHOW',
+  ACTIVE: 'ACTIVE'
+};
+
+var IconDiv = _styledComponents["default"].div.attrs({
+  className: 'tooltip-chicklet__icon'
+})(_templateObject4 || (_templateObject4 = (0, _taggedTemplateLiteral2["default"])(["\n  color: ", ";\n"])), function (props) {
+  return props.status === hashStyles.SHOW ? props.theme.subtextColorActive : props.status === hashStyles.ACTIVE ? props.theme.activeColor : props.theme.textColor;
+});
+
+function getFormatTooltip(formatLabels, format) {
+  if (!format) {
+    return null;
+  }
+
+  var formatLabel = formatLabels.find(function (fl) {
+    return getValue(fl) === format;
+  });
+
+  if (formatLabel) {
+    return formatLabel.label;
+  }
+
+  return (0, _typeof2["default"])(format) === 'object' ? JSON.stringify(format, null, 2) : String(format);
+}
+
+function TooltipChickletFactory(dataId, config, onChange, fields) {
+  var TooltipChicklet = /*#__PURE__*/function (_Component) {
+    (0, _inherits2["default"])(TooltipChicklet, _Component);
+
+    var _super = _createSuper(TooltipChicklet);
+
+    function TooltipChicklet() {
+      var _this;
+
+      (0, _classCallCheck2["default"])(this, TooltipChicklet);
+
+      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), "state", {
+        show: false
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "node", void 0);
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handleClickOutside", function (e) {
+        if (_this.node.contains(e.target)) {
+          return;
+        }
+      });
+      return _this;
+    }
+
+    (0, _createClass2["default"])(TooltipChicklet, [{
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        document.addEventListener('mousedown', this.handleClickOutside, false);
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        document.removeEventListener('mousedown', this.handleClickOutside, false);
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this2 = this;
+
+        var _this$props = this.props,
+            disabled = _this$props.disabled,
+            item = _this$props.item,
+            displayOption = _this$props.displayOption,
+            remove = _this$props.remove;
+        var show = this.state.show;
+        var tooltipField = config.fieldsToShow[dataId].find(function (fieldToShow) {
+          return fieldToShow.name === item.name;
+        });
+
+        if (!tooltipField) {
+          return null;
+        }
+
+        var formatLabels = getFormatLabels(fields, tooltipField.name);
+        var hasFormat = Boolean(tooltipField.format);
+        var selectionIndex = formatLabels.findIndex(function (fl) {
+          return getValue(fl) === tooltipField.format;
+        });
+        var hashStyle = show ? hashStyles.SHOW : hasFormat ? hashStyles.ACTIVE : null;
+        return /*#__PURE__*/_react["default"].createElement(_chickletedInput.ChickletButton, {
+          ref: function ref(node) {
+            return _this2.node = node;
+          }
+        }, /*#__PURE__*/_react["default"].createElement(_chickletedInput.ChickletTag, null, displayOption(item)), formatLabels.length > 1 && /*#__PURE__*/_react["default"].createElement(ChickletAddonWrapper, null, /*#__PURE__*/_react["default"].createElement(_tippyTooltip["default"], {
+          placement: "top",
+          render: function render() {
+            return /*#__PURE__*/_react["default"].createElement("span", null, hasFormat ? getFormatTooltip(formatLabels, tooltipField.format) : /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+              id: 'fieldSelector.formatting'
+            }));
+          }
+        }, /*#__PURE__*/_react["default"].createElement(ChickletAddon, null, /*#__PURE__*/_react["default"].createElement(IconDiv, {
+          status: hashStyle
+        }, /*#__PURE__*/_react["default"].createElement(_icons.Hash, {
+          height: "8px",
+          onClick: function onClick(e) {
+            e.stopPropagation();
+
+            _this2.setState({
+              show: Boolean(!show)
+            });
+          }
+        })))), show && /*#__PURE__*/_react["default"].createElement(StyledPopover, null, /*#__PURE__*/_react["default"].createElement(_dropdownList["default"], {
+          options: formatLabels,
+          selectionIndex: selectionIndex,
+          displayOption: function displayOption(_ref) {
+            var label = _ref.label;
+            return label;
+          },
+          onOptionSelected: function onOptionSelected(result, e) {
+            e.stopPropagation();
+
+            _this2.setState({
+              show: false
+            });
+
+            var oldFieldsToShow = config.fieldsToShow[dataId];
+            var fieldsToShow = oldFieldsToShow.map(function (fieldToShow) {
+              return fieldToShow.name === tooltipField.name ? {
+                name: tooltipField.name,
+                format: getValue(result)
+              } : fieldToShow;
+            });
+
+            var newConfig = _objectSpread(_objectSpread({}, config), {}, {
+              fieldsToShow: _objectSpread(_objectSpread({}, config.fieldsToShow), {}, (0, _defineProperty2["default"])({}, dataId, fieldsToShow))
+            });
+
+            onChange(newConfig);
+          }
+        }))), /*#__PURE__*/_react["default"].createElement(_icons.Delete, {
+          onClick: disabled ? null : remove
+        }));
+      }
+    }]);
+    return TooltipChicklet;
+  }(_react.Component);
+
+  return (0, _reactOnclickoutside["default"])(TooltipChicklet);
+}
+
+var _default = TooltipChickletFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/side-panel/interaction-panel/tooltip-config/tooltip-chicklet.tsx"],"names":["TIME_DISPLAY","getValue","fmt","TOOLTIP_KEY","addDTimeLabel","formats","map","f","label","type","TOOLTIP_FORMAT_TYPES","DATE_TIME","DATE","getFormatLabels","fields","fieldName","fieldType","find","name","tooltipTypes","FIELD_OPTS","format","tooltip","formatLabels","Object","values","TOOLTIP_FORMATS","filter","t","includes","ChickletAddonWrapper","styled","div","ChickletAddon","StyledPopover","hashStyles","SHOW","ACTIVE","IconDiv","attrs","className","props","status","theme","subtextColorActive","activeColor","textColor","getFormatTooltip","formatLabel","fl","JSON","stringify","String","TooltipChickletFactory","dataId","config","onChange","TooltipChicklet","show","e","node","contains","target","document","addEventListener","handleClickOutside","removeEventListener","disabled","item","displayOption","remove","state","tooltipField","fieldsToShow","fieldToShow","hasFormat","Boolean","selectionIndex","findIndex","hashStyle","length","stopPropagation","setState","result","oldFieldsToShow","newConfig","Component"],"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 React, {Component, ComponentType} from 'react';\nimport styled from 'styled-components';\nimport {ChickletButton, ChickletTag} from '../../../common/item-selector/chickleted-input';\nimport {Hash, Delete} from '../../../common/icons';\nimport DropdownList from '../../../common/item-selector/dropdown-list';\nimport {FormattedMessage} from '@kepler.gl/localization';\nimport onClickOutside from 'react-onclickoutside';\nimport {\n  FIELD_OPTS,\n  TOOLTIP_FORMATS,\n  TOOLTIP_FORMAT_TYPES,\n  TOOLTIP_KEY\n} from '@kepler.gl/constants';\nimport {getFormatter} from '@kepler.gl/utils';\nimport TippyTooltip from '../../../common/tippy-tooltip';\n\ninterface TooltipChickletProps {\n  disabled: boolean;\n  item: {name: string};\n  displayOption: Function;\n  remove: any;\n}\n\ntype TooltipConfig = {\n  fieldsToShow: {\n    [key: string]: {name: string; format: string | null}[];\n  };\n  compareMode: boolean;\n  compareType: string[];\n};\n\ntype TooltipFields = {\n  format?: string;\n  id?: string;\n  name?: string;\n  fieldIdx?: number;\n  type?: number;\n};\n\ntype TimeLabelFormat = {\n  id: string;\n  format: string | null;\n  type: string;\n  label: string;\n};\n\ntype IconDivProps = {\n  status: string | null;\n};\n\nconst TIME_DISPLAY = '2020-05-11 14:00';\nconst getValue = fmt => fmt[TOOLTIP_KEY];\n\nconst addDTimeLabel = (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(getValue(f))(TIME_DISPLAY)\n        : f.label\n  }));\n\nfunction getFormatLabels(fields: any, fieldName: string) {\n  const fieldType = fields.find((f: TooltipFields) => f.name === fieldName).type;\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 addDTimeLabel(formatLabels);\n}\n\nconst ChickletAddonWrapper = styled.div`\n  position: relative;\n`;\n\nconst ChickletAddon = styled.div`\n  margin-right: 4px;\n`;\n\nconst StyledPopover = styled.div`\n  margin-left: -64px;\n  position: absolute;\n  top: 20px;\n  width: 140px;\n  z-index: 101;\n`;\n\nconst hashStyles = {\n  SHOW: 'SHOW',\n  ACTIVE: 'ACTIVE'\n};\n\nconst IconDiv = styled.div.attrs({\n  className: 'tooltip-chicklet__icon'\n})<IconDivProps>`\n  color: ${props =>\n    props.status === hashStyles.SHOW\n      ? props.theme.subtextColorActive\n      : props.status === hashStyles.ACTIVE\n      ? props.theme.activeColor\n      : props.theme.textColor};\n`;\n\nfunction getFormatTooltip(formatLabels: TimeLabelFormat[], format: string | null) {\n  if (!format) {\n    return null;\n  }\n  const formatLabel = formatLabels.find(fl => getValue(fl) === format);\n  if (formatLabel) {\n    return formatLabel.label;\n  }\n  return typeof format === 'object' ? JSON.stringify(format, null, 2) : String(format);\n}\n\nfunction TooltipChickletFactory(\n  dataId: string,\n  config: TooltipConfig,\n  onChange: (cfg: TooltipConfig) => void,\n  fields: TooltipFields[]\n): ComponentType<TooltipChickletProps> {\n  class TooltipChicklet extends Component<TooltipChickletProps> {\n    state = {\n      show: false\n    };\n    private node!: HTMLDivElement;\n\n    componentDidMount() {\n      document.addEventListener('mousedown', this.handleClickOutside, false);\n    }\n\n    componentWillUnmount() {\n      document.removeEventListener('mousedown', this.handleClickOutside, false);\n    }\n\n    handleClickOutside = (e: any) => {\n      if (this.node.contains(e.target)) {\n        return;\n      }\n    };\n\n    render() {\n      const {disabled, item, displayOption, remove} = this.props;\n      const {show} = this.state;\n      const tooltipField = config.fieldsToShow[dataId].find(\n        fieldToShow => fieldToShow.name === item.name\n      );\n      if (!tooltipField) {\n        return null;\n      }\n      const formatLabels = getFormatLabels(fields, tooltipField.name);\n      const hasFormat = Boolean(tooltipField.format);\n      const selectionIndex = formatLabels.findIndex(fl => getValue(fl) === tooltipField.format);\n      const hashStyle = show ? hashStyles.SHOW : hasFormat ? hashStyles.ACTIVE : null;\n\n      return (\n        <ChickletButton ref={(node: HTMLDivElement) => (this.node = node)}>\n          <ChickletTag>{displayOption(item)}</ChickletTag>\n          {formatLabels.length > 1 && (\n            <ChickletAddonWrapper>\n              <TippyTooltip\n                placement=\"top\"\n                render={() => (\n                  <span>\n                    {hasFormat ? (\n                      getFormatTooltip(formatLabels, tooltipField.format)\n                    ) : (\n                      <FormattedMessage id={'fieldSelector.formatting'} />\n                    )}\n                  </span>\n                )}\n              >\n                <ChickletAddon>\n                  <IconDiv status={hashStyle}>\n                    <Hash\n                      height=\"8px\"\n                      onClick={e => {\n                        e.stopPropagation();\n                        this.setState({show: Boolean(!show)});\n                      }}\n                    />\n                  </IconDiv>\n                </ChickletAddon>\n              </TippyTooltip>\n              {show && (\n                <StyledPopover>\n                  <DropdownList\n                    options={formatLabels}\n                    selectionIndex={selectionIndex}\n                    displayOption={({label}) => label}\n                    onOptionSelected={(result, e) => {\n                      e.stopPropagation();\n                      this.setState({\n                        show: false\n                      });\n\n                      const oldFieldsToShow = config.fieldsToShow[dataId];\n                      const fieldsToShow = oldFieldsToShow.map(fieldToShow => {\n                        return fieldToShow.name === tooltipField.name\n                          ? {\n                              name: tooltipField.name,\n                              format: getValue(result)\n                            }\n                          : fieldToShow;\n                      });\n                      const newConfig = {\n                        ...config,\n                        fieldsToShow: {\n                          ...config.fieldsToShow,\n                          [dataId]: fieldsToShow\n                        }\n                      };\n                      onChange(newConfig);\n                    }}\n                  />\n                </StyledPopover>\n              )}\n            </ChickletAddonWrapper>\n          )}\n          <Delete onClick={disabled ? null : remove} />\n        </ChickletButton>\n      );\n    }\n  }\n  return onClickOutside(TooltipChicklet);\n}\n\nexport default TooltipChickletFactory;\n"]}

package/dist/side-panel/interaction-panel/tooltip-config.d.ts

@@ -0,0 +1,38 @@
+import React from 'react';
+import { IntlShape } from 'react-intl';
+import DatasetTagFactory from '../common/dataset-tag';
+import FieldSelectorFactory from '../../common/field-selector';
+import { Datasets } from '@kepler.gl/table';
+declare type TooltipConfigProps = {
+    config: {
+        fieldsToShow: {
+            [key: string]: {
+                name: string;
+                format: string | null;
+            }[];
+        };
+        compareMode: boolean;
+        compareType: string | null;
+    };
+    onChange: (config: {
+        fieldsToShow: {
+            [key: string]: {
+                name: string;
+                format: string | null;
+            }[];
+        };
+        compareMode: boolean;
+        compareType: string | null;
+    }) => void;
+    datasets: Datasets;
+    intl: IntlShape;
+};
+declare function TooltipConfigFactory(DatasetTag: ReturnType<typeof DatasetTagFactory>, FieldSelector: ReturnType<typeof FieldSelectorFactory>): React.ForwardRefExoticComponent<import("react-intl").Omit<TooltipConfigProps, "intl"> & {
+    forwardedRef?: React.Ref<any> | undefined;
+} & React.RefAttributes<any>> & {
+    WrappedComponent: React.ComponentType<TooltipConfigProps>;
+};
+declare namespace TooltipConfigFactory {
+    var deps: (typeof FieldSelectorFactory | typeof DatasetTagFactory)[];
+}
+export default TooltipConfigFactory;

package/dist/side-panel/interaction-panel/tooltip-config.js

@@ -0,0 +1,185 @@
+// 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.
+
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _reactIntl = require("react-intl");
+
+var _localization = require("@kepler.gl/localization");
+
+var _styledComponents2 = require("../../common/styled-components");
+
+var _datasetTag = _interopRequireDefault(require("../common/dataset-tag"));
+
+var _tooltipChicklet = _interopRequireDefault(require("./tooltip-config/tooltip-chicklet"));
+
+var _switch = _interopRequireDefault(require("../../common/switch"));
+
+var _itemSelector = _interopRequireDefault(require("../../common/item-selector/item-selector"));
+
+var _constants = require("@kepler.gl/constants");
+
+var _fieldSelector = _interopRequireDefault(require("../../common/field-selector"));
+
+var _templateObject, _templateObject2, _templateObject3;
+
+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 TooltipConfigWrapper = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  .item-selector > div > div {\n    overflow: visible;\n  }\n"])));
+
+var ButtonWrapper = _styledComponents["default"].div(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  display: inherit;\n  padding: 0;\n\n  .button.clear-all {\n    background: transparent;\n    color: ", ";\n    margin: 0 0 0 8px;\n    padding: 0;\n\n    &:hover {\n      color: ", ";\n    }\n  }\n"])), function (props) {
+  return props.theme.subtextColor;
+}, function (props) {
+  return props.theme.textColor;
+});
+
+var CompareSwitchWrapper = _styledComponents["default"].div(_templateObject3 || (_templateObject3 = (0, _taggedTemplateLiteral2["default"])(["\n  color: ", ";\n  display: flex;\n  font-size: ", ";\n  justify-content: space-between;\n  line-height: 11px;\n  margin-bottom: 8px;\n"])), function (props) {
+  return props.theme.labelColor;
+}, function (props) {
+  return props.theme.inputFontSize;
+});
+
+TooltipConfigFactory.deps = [_datasetTag["default"], _fieldSelector["default"]];
+
+function TooltipConfigFactory(DatasetTag, FieldSelector) {
+  var DatasetTooltipConfig = function DatasetTooltipConfig(_ref) {
+    var config = _ref.config,
+        onChange = _ref.onChange,
+        dataset = _ref.dataset;
+    var dataId = dataset.id;
+    return /*#__PURE__*/_react["default"].createElement(_styledComponents2.SidePanelSection, {
+      key: dataId
+    }, /*#__PURE__*/_react["default"].createElement(_styledComponents2.SBFlexboxNoMargin, null, /*#__PURE__*/_react["default"].createElement(DatasetTag, {
+      dataset: dataset
+    }), Boolean(config.fieldsToShow[dataId].length) && /*#__PURE__*/_react["default"].createElement(ButtonWrapper, null, /*#__PURE__*/_react["default"].createElement(_styledComponents2.Button, {
+      className: "clear-all",
+      onClick: function onClick() {
+        var newConfig = _objectSpread(_objectSpread({}, config), {}, {
+          fieldsToShow: _objectSpread(_objectSpread({}, config.fieldsToShow), {}, (0, _defineProperty2["default"])({}, dataId, []))
+        });
+
+        onChange(newConfig);
+      },
+      width: "54px",
+      secondary: true
+    }, /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+      id: "fieldSelector.clearAll"
+    })))), /*#__PURE__*/_react["default"].createElement(FieldSelector, {
+      fields: dataset.fields,
+      value: config.fieldsToShow[dataId],
+      onSelect: function onSelect(selected) {
+        var newConfig = _objectSpread(_objectSpread({}, config), {}, {
+          fieldsToShow: _objectSpread(_objectSpread({}, config.fieldsToShow), {}, (0, _defineProperty2["default"])({}, dataId, selected.map(function (f) {
+            return config.fieldsToShow[dataId].find(function (tooltipField) {
+              return tooltipField.name === f.name;
+            }) || {
+              name: f.name,
+              // default initial tooltip is null
+              format: null
+            };
+          })))
+        });
+
+        onChange(newConfig);
+      },
+      closeOnSelect: false,
+      multiSelect: true,
+      inputTheme: "secondary" // @ts-expect-error
+      ,
+      CustomChickletComponent: (0, _tooltipChicklet["default"])(dataId, config, onChange, dataset.fields)
+    }));
+  };
+
+  var TooltipConfig = function TooltipConfig(_ref2) {
+    var config = _ref2.config,
+        datasets = _ref2.datasets,
+        _onChange = _ref2.onChange,
+        intl = _ref2.intl;
+    return /*#__PURE__*/_react["default"].createElement(TooltipConfigWrapper, null, Object.keys(config.fieldsToShow).map(function (dataId) {
+      return dataId === _constants.GEOCODER_DATASET_NAME ? null : /*#__PURE__*/_react["default"].createElement(DatasetTooltipConfig, {
+        key: dataId,
+        config: config,
+        onChange: _onChange,
+        dataset: datasets[dataId]
+      });
+    }), /*#__PURE__*/_react["default"].createElement(CompareSwitchWrapper, null, /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+      id: "compare.modeLabel"
+    }), /*#__PURE__*/_react["default"].createElement(_switch["default"], {
+      checked: config.compareMode,
+      id: "compare-mode-toggle",
+      onChange: function onChange() {
+        var newConfig = _objectSpread(_objectSpread({}, config), {}, {
+          compareMode: !config.compareMode
+        });
+
+        _onChange(newConfig);
+      },
+      secondary: true
+    })), /*#__PURE__*/_react["default"].createElement(_styledComponents2.SidePanelSection, null, /*#__PURE__*/_react["default"].createElement(_styledComponents2.PanelLabel, null, /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+      id: "compare.typeLabel"
+    })), /*#__PURE__*/_react["default"].createElement(_itemSelector["default"], {
+      disabled: !config.compareMode,
+      displayOption: function displayOption(d) {
+        return intl.formatMessage({
+          id: "compare.types.".concat(d)
+        });
+      },
+      selectedItems: config.compareType,
+      options: Object.values(_constants.COMPARE_TYPES),
+      multiSelect: false,
+      searchable: false,
+      inputTheme: 'secondary',
+      getOptionValue: function getOptionValue(d) {
+        return d;
+      },
+      onChange: function onChange(option) {
+        var newConfig = _objectSpread(_objectSpread({}, config), {}, {
+          // @ts-expect-error
+          compareType: option
+        });
+
+        _onChange(newConfig);
+      }
+    })));
+  };
+
+  return (0, _reactIntl.injectIntl)(TooltipConfig);
+}
+
+var _default = TooltipConfigFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/side-panel/interaction-panel/tooltip-config.tsx"],"names":["TooltipConfigWrapper","styled","div","ButtonWrapper","props","theme","subtextColor","textColor","CompareSwitchWrapper","labelColor","inputFontSize","TooltipConfigFactory","deps","DatasetTagFactory","FieldSelectorFactory","DatasetTag","FieldSelector","DatasetTooltipConfig","config","onChange","dataset","dataId","id","Boolean","fieldsToShow","length","newConfig","fields","selected","map","f","find","tooltipField","name","format","TooltipConfig","datasets","intl","Object","keys","GEOCODER_DATASET_NAME","compareMode","d","formatMessage","compareType","values","COMPARE_TYPES","option"],"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 React from 'react';\nimport styled from 'styled-components';\nimport {injectIntl, IntlShape} from 'react-intl';\nimport {FormattedMessage} from '@kepler.gl/localization';\n\nimport {\n  SidePanelSection,\n  SBFlexboxNoMargin,\n  Button,\n  PanelLabel\n} from '../../common/styled-components';\nimport DatasetTagFactory from '../common/dataset-tag';\nimport TooltipChickletFactory from './tooltip-config/tooltip-chicklet';\nimport Switch from '../../common/switch';\nimport ItemSelector from '../../common/item-selector/item-selector';\nimport {COMPARE_TYPES, GEOCODER_DATASET_NAME} from '@kepler.gl/constants';\nimport FieldSelectorFactory from '../../common/field-selector';\nimport KeplerTable, {Datasets} from '@kepler.gl/table';\n\nconst TooltipConfigWrapper = styled.div`\n  .item-selector > div > div {\n    overflow: visible;\n  }\n`;\n\nconst ButtonWrapper = styled.div`\n  display: inherit;\n  padding: 0;\n\n  .button.clear-all {\n    background: transparent;\n    color: ${props => props.theme.subtextColor};\n    margin: 0 0 0 8px;\n    padding: 0;\n\n    &:hover {\n      color: ${props => props.theme.textColor};\n    }\n  }\n`;\n\nconst CompareSwitchWrapper = styled.div`\n  color: ${props => props.theme.labelColor};\n  display: flex;\n  font-size: ${props => props.theme.inputFontSize};\n  justify-content: space-between;\n  line-height: 11px;\n  margin-bottom: 8px;\n`;\n\ntype TooltipConfigProps = {\n  config: {\n    fieldsToShow: {\n      [key: string]: {name: string; format: string | null}[];\n    };\n    compareMode: boolean;\n    compareType: string | null;\n  };\n  onChange: (config: {\n    fieldsToShow: {\n      [key: string]: {name: string; format: string | null}[];\n    };\n    compareMode: boolean;\n    compareType: string | null;\n  }) => void;\n  datasets: Datasets;\n  intl: IntlShape;\n};\n\ntype DatasetTooltipConfigProps = {\n  config: {\n    fieldsToShow: {\n      [key: string]: {name: string; format: string | null}[];\n    };\n    compareMode: boolean;\n    compareType: string | null;\n  };\n  onChange: (config: {\n    fieldsToShow: {\n      [key: string]: {name: string; format: string | null}[];\n    };\n    compareMode: boolean;\n    compareType: string | null;\n  }) => void;\n  dataset: KeplerTable;\n};\n\nTooltipConfigFactory.deps = [DatasetTagFactory, FieldSelectorFactory];\nfunction TooltipConfigFactory(\n  DatasetTag: ReturnType<typeof DatasetTagFactory>,\n  FieldSelector: ReturnType<typeof FieldSelectorFactory>\n) {\n  const DatasetTooltipConfig = ({config, onChange, dataset}: DatasetTooltipConfigProps) => {\n    const dataId = dataset.id;\n    return (\n      <SidePanelSection key={dataId}>\n        <SBFlexboxNoMargin>\n          <DatasetTag dataset={dataset} />\n          {Boolean(config.fieldsToShow[dataId].length) && (\n            <ButtonWrapper>\n              <Button\n                className=\"clear-all\"\n                onClick={() => {\n                  const newConfig = {\n                    ...config,\n                    fieldsToShow: {\n                      ...config.fieldsToShow,\n                      [dataId]: []\n                    }\n                  };\n                  onChange(newConfig);\n                }}\n                width=\"54px\"\n                secondary\n              >\n                <FormattedMessage id=\"fieldSelector.clearAll\" />\n              </Button>\n            </ButtonWrapper>\n          )}\n        </SBFlexboxNoMargin>\n        <FieldSelector\n          fields={dataset.fields}\n          value={config.fieldsToShow[dataId]}\n          onSelect={selected => {\n            const newConfig: DatasetTooltipConfigProps['config'] = {\n              ...config,\n              fieldsToShow: {\n                ...config.fieldsToShow,\n                // @ts-expect-error\n                [dataId]: selected.map(\n                  f =>\n                    config.fieldsToShow[dataId].find(\n                      tooltipField => tooltipField.name === f.name\n                    ) || {\n                      name: f.name,\n                      // default initial tooltip is null\n                      format: null\n                    }\n                )\n              }\n            };\n            onChange(newConfig);\n          }}\n          closeOnSelect={false}\n          multiSelect\n          inputTheme=\"secondary\"\n          // @ts-expect-error\n          CustomChickletComponent={TooltipChickletFactory(dataId, config, onChange, dataset.fields)}\n        />\n      </SidePanelSection>\n    );\n  };\n\n  const TooltipConfig = ({config, datasets, onChange, intl}: TooltipConfigProps) => {\n    return (\n      <TooltipConfigWrapper>\n        {Object.keys(config.fieldsToShow).map(dataId =>\n          dataId === GEOCODER_DATASET_NAME ? null : (\n            <DatasetTooltipConfig\n              key={dataId}\n              config={config}\n              onChange={onChange}\n              dataset={datasets[dataId]}\n            />\n          )\n        )}\n        <CompareSwitchWrapper>\n          <FormattedMessage id=\"compare.modeLabel\" />\n          <Switch\n            checked={config.compareMode}\n            id=\"compare-mode-toggle\"\n            onChange={() => {\n              const newConfig = {\n                ...config,\n                compareMode: !config.compareMode\n              };\n              onChange(newConfig);\n            }}\n            secondary\n          />\n        </CompareSwitchWrapper>\n        <SidePanelSection>\n          <PanelLabel>\n            <FormattedMessage id=\"compare.typeLabel\" />\n          </PanelLabel>\n          <ItemSelector\n            disabled={!config.compareMode}\n            displayOption={d =>\n              intl.formatMessage({\n                id: `compare.types.${d}`\n              })\n            }\n            selectedItems={config.compareType}\n            options={Object.values(COMPARE_TYPES)}\n            multiSelect={false}\n            searchable={false}\n            inputTheme={'secondary'}\n            getOptionValue={d => d}\n            onChange={option => {\n              const newConfig: TooltipConfigProps['config'] = {\n                ...config,\n                // @ts-expect-error\n                compareType: option\n              };\n              onChange(newConfig);\n            }}\n          />\n        </SidePanelSection>\n      </TooltipConfigWrapper>\n    );\n  };\n\n  return injectIntl(TooltipConfig);\n}\n\nexport default TooltipConfigFactory;\n"]}

package/dist/side-panel/layer-manager.d.ts

@@ -0,0 +1,39 @@
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl';
+import LayerListFactory from './layer-panel/layer-list';
+import DatasetLayerGroupFactory from './layer-panel/dataset-layer-group';
+import PanelViewListToggleFactory from './layer-panel/panel-view-list-toggle';
+import PanelTitleFactory from './panel-title';
+import DatasetSectionFactory from './layer-panel/dataset-section';
+import AddLayerButtonFactory from './layer-panel/add-layer-button';
+import { Layer, LayerClassesType } from '@kepler.gl/layers';
+import { UIStateActions, VisStateActions, ActionHandler } from '@kepler.gl/actions';
+import { SidePanelItem } from '../types';
+import { LayerPanelListView } from '@kepler.gl/types';
+import { Datasets } from '@kepler.gl/table';
+declare type LayerManagerProps = {
+    datasets: Datasets;
+    layers: Layer[];
+    layerOrder: number[];
+    layerClasses: LayerClassesType;
+    layerBlending: string;
+    uiStateActions: typeof UIStateActions;
+    visStateActions: typeof VisStateActions;
+    showAddDataModal: () => void;
+    removeDataset: ActionHandler<typeof UIStateActions.openDeleteModal>;
+    showDatasetTable: ActionHandler<typeof VisStateActions.showDatasetTable>;
+    updateTableColor: ActionHandler<typeof VisStateActions.updateTableColor>;
+    layerPanelListView: LayerPanelListView;
+    panelMetadata: SidePanelItem;
+} & WrappedComponentProps;
+declare function LayerManagerFactory(LayerList: ReturnType<typeof LayerListFactory>, DatasetLayerGroup: ReturnType<typeof DatasetLayerGroupFactory>, PanelViewListToggle: ReturnType<typeof PanelViewListToggleFactory>, PanelTitle: ReturnType<typeof PanelTitleFactory>, DatasetSection: ReturnType<typeof DatasetSectionFactory>, AddLayerButton: ReturnType<typeof AddLayerButtonFactory>): React.ForwardRefExoticComponent<import("react-intl").Omit<LayerManagerProps, "intl"> & {
+    forwardedRef?: React.Ref<any> | undefined;
+} & React.RefAttributes<any>> & {
+    WrappedComponent: React.ComponentType<LayerManagerProps>;
+};
+declare namespace LayerManagerFactory {
+    var deps: ((() => import("styled-components").StyledComponent<"div", any, {
+        className: string;
+    }, "className">) | typeof AddLayerButtonFactory | typeof LayerListFactory | typeof DatasetLayerGroupFactory | typeof PanelViewListToggleFactory | typeof DatasetSectionFactory)[];
+}
+export default LayerManagerFactory;