@kepler.gl/components 3.3.0-alpha.1 → 3.3.0-alpha.10

package/dist/esm/side-panel/interaction-panel/interaction-panel.js

@@ -0,0 +1,114 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject;
+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) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useState, useCallback } from 'react';
+import styled from 'styled-components';
+import Switch from '../../common/switch';
+import BrushConfigFactory from './brush-config';
+import TooltipConfigFactory from './tooltip-config';
+import GeocoderConfigFactory from './geocoder-config';
+import { StyledPanelHeader, PanelHeaderTitle, PanelHeaderContent, PanelContent } from '../../common/styled-components';
+import { Messages, Crosshairs, CursorClick, Pin } from '../../common/icons';
+import { FormattedMessage } from '@kepler.gl/localization';
+var StyledInteractionPanel = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  padding-bottom: 6px;\n  contain: layout paint;\n"])));
+InteractionPanelFactory.deps = [TooltipConfigFactory, BrushConfigFactory, GeocoderConfigFactory];
+var INTERACTION_CONFIG_ICONS = {
+  tooltip: Messages,
+  geocoder: Pin,
+  brush: Crosshairs,
+  coordinate: CursorClick
+};
+function InteractionPanelFactory(TooltipConfig, BrushConfig, GeocoderConfig) {
+  var InteractionPanel = function InteractionPanel(_ref) {
+    var config = _ref.config,
+      onConfigChange = _ref.onConfigChange,
+      datasets = _ref.datasets,
+      setColumnDisplayFormat = _ref.setColumnDisplayFormat,
+      _ref$interactionConfi = _ref.interactionConfigIcons,
+      interactionConfigIcons = _ref$interactionConfi === void 0 ? INTERACTION_CONFIG_ICONS : _ref$interactionConfi;
+    var _useState = useState(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      isConfigActive = _useState2[0],
+      setIsConfigAction = _useState2[1];
+    var _updateConfig = useCallback(function (newProp) {
+      onConfigChange(_objectSpread(_objectSpread({}, config), newProp));
+    }, [onConfigChange, config]);
+    var onDisplayFormatChange = useCallback(function (dataId, column, displayFormat) {
+      setColumnDisplayFormat(dataId, _defineProperty({}, column, displayFormat));
+    }, [setColumnDisplayFormat]);
+    var togglePanelActive = useCallback(function () {
+      setIsConfigAction(!isConfigActive);
+    }, [setIsConfigAction, isConfigActive]);
+    var enabled = config.enabled;
+    var toggleEnableConfig = useCallback(function () {
+      _updateConfig({
+        enabled: !enabled
+      });
+    }, [_updateConfig, enabled]);
+    var onChange = useCallback(function (newConfig) {
+      return _updateConfig({
+        config: newConfig
+      });
+    }, [_updateConfig]);
+    var IconComponent = interactionConfigIcons[config.id];
+    var template = null;
+    switch (config.id) {
+      case 'tooltip':
+        template = /*#__PURE__*/React.createElement(TooltipConfig, {
+          datasets: datasets,
+          config: config.config,
+          onChange: onChange,
+          onDisplayFormatChange: onDisplayFormatChange
+        });
+        break;
+      case 'brush':
+        template = /*#__PURE__*/React.createElement(BrushConfig, {
+          config: config.config,
+          onChange: onChange
+        });
+        break;
+      case 'geocoder':
+        template = /*#__PURE__*/React.createElement(GeocoderConfig, {
+          config: config.config,
+          onChange: onChange
+        });
+        break;
+      default:
+        break;
+    }
+    return /*#__PURE__*/React.createElement(StyledInteractionPanel, {
+      className: "interaction-panel"
+    }, /*#__PURE__*/React.createElement(StyledPanelHeader, {
+      className: "interaction-panel__header",
+      onClick: togglePanelActive
+    }, /*#__PURE__*/React.createElement(PanelHeaderContent, {
+      className: "interaction-panel__header__content"
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "interaction-panel__header__icon icon"
+    }, IconComponent ? /*#__PURE__*/React.createElement(IconComponent, {
+      height: "16px"
+    }) : null), /*#__PURE__*/React.createElement("div", {
+      className: "interaction-panel__header__title"
+    }, /*#__PURE__*/React.createElement(PanelHeaderTitle, null, /*#__PURE__*/React.createElement(FormattedMessage, {
+      id: config.label
+    })))), /*#__PURE__*/React.createElement("div", {
+      className: "interaction-panel__header__actions"
+    }, /*#__PURE__*/React.createElement(Switch, {
+      checked: config.enabled,
+      id: "".concat(config.id, "-toggle"),
+      onChange: toggleEnableConfig,
+      secondary: true
+    }))), config.enabled && template && /*#__PURE__*/React.createElement(PanelContent, {
+      className: "interaction-panel__content"
+    }, template));
+  };
+  return InteractionPanel;
+}
+export default InteractionPanelFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useState","useCallback","styled","Switch","BrushConfigFactory","TooltipConfigFactory","GeocoderConfigFactory","StyledPanelHeader","PanelHeaderTitle","PanelHeaderContent","PanelContent","Messages","Crosshairs","CursorClick","Pin","FormattedMessage","StyledInteractionPanel","div","_templateObject","_taggedTemplateLiteral","InteractionPanelFactory","deps","INTERACTION_CONFIG_ICONS","tooltip","geocoder","brush","coordinate","TooltipConfig","BrushConfig","GeocoderConfig","InteractionPanel","_ref","config","onConfigChange","datasets","setColumnDisplayFormat","_ref$interactionConfi","interactionConfigIcons","_useState","_useState2","_slicedToArray","isConfigActive","setIsConfigAction","_updateConfig","newProp","_objectSpread","onDisplayFormatChange","dataId","column","displayFormat","_defineProperty","togglePanelActive","enabled","toggleEnableConfig","onChange","newConfig","IconComponent","id","template","createElement","className","onClick","height","label","checked","concat","secondary"],"sources":["../../../../src/side-panel/interaction-panel/interaction-panel.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useState, ComponentType, ReactElement, useCallback} from 'react';\nimport styled from 'styled-components';\nimport Switch from '../../common/switch';\nimport BrushConfigFactory from './brush-config';\nimport TooltipConfigFactory from './tooltip-config';\nimport GeocoderConfigFactory from './geocoder-config';\nimport {Datasets} from '@kepler.gl/table';\nimport {InteractionConfig, ValueOf} from '@kepler.gl/types';\nimport {\n  setColumnDisplayFormat as setColumnDisplayFormatAction,\n  ActionHandler\n} from '@kepler.gl/actions';\n\nimport {\n  StyledPanelHeader,\n  PanelHeaderTitle,\n  PanelHeaderContent,\n  PanelContent\n} from '../../common/styled-components';\nimport {Messages, Crosshairs, CursorClick, Pin} from '../../common/icons';\n\nimport {FormattedMessage} from '@kepler.gl/localization';\n\ninterface InteractionPanelProps {\n  datasets: Datasets;\n  config: ValueOf<InteractionConfig>;\n  onConfigChange: any;\n  interactionConfigIcons?: {\n    [key: string]: React.ElementType;\n  };\n  setColumnDisplayFormat: ActionHandler<typeof setColumnDisplayFormatAction>;\n}\n\nconst StyledInteractionPanel = styled.div`\n  padding-bottom: 6px;\n  contain: layout paint;\n`;\n\nInteractionPanelFactory.deps = [TooltipConfigFactory, BrushConfigFactory, GeocoderConfigFactory];\n\nconst INTERACTION_CONFIG_ICONS: {[key: string]: React.ElementType} = {\n  tooltip: Messages,\n  geocoder: Pin,\n  brush: Crosshairs,\n  coordinate: CursorClick\n};\n\nfunction InteractionPanelFactory(\n  TooltipConfig: ReturnType<typeof TooltipConfigFactory>,\n  BrushConfig: ReturnType<typeof BrushConfigFactory>,\n  GeocoderConfig: ReturnType<typeof GeocoderConfigFactory>\n): ComponentType<InteractionPanelProps> {\n  const InteractionPanel: React.FC<InteractionPanelProps> = ({\n    config,\n    onConfigChange,\n    datasets,\n    setColumnDisplayFormat,\n    interactionConfigIcons = INTERACTION_CONFIG_ICONS\n  }) => {\n    const [isConfigActive, setIsConfigAction] = useState(false);\n\n    const _updateConfig = useCallback(\n      newProp => {\n        onConfigChange({\n          ...config,\n          ...newProp\n        });\n      },\n      [onConfigChange, config]\n    );\n\n    const onDisplayFormatChange = useCallback(\n      (dataId, column, displayFormat) => {\n        setColumnDisplayFormat(dataId, {[column]: displayFormat});\n      },\n      [setColumnDisplayFormat]\n    );\n\n    const togglePanelActive = useCallback(() => {\n      setIsConfigAction(!isConfigActive);\n    }, [setIsConfigAction, isConfigActive]);\n\n    const {enabled} = config;\n    const toggleEnableConfig = useCallback(() => {\n      _updateConfig({enabled: !enabled});\n    }, [_updateConfig, enabled]);\n\n    const onChange = useCallback(newConfig => _updateConfig({config: newConfig}), [_updateConfig]);\n\n    const IconComponent = interactionConfigIcons[config.id];\n\n    let template: ReactElement | null = null;\n\n    switch (config.id) {\n      case 'tooltip':\n        template = (\n          <TooltipConfig\n            datasets={datasets}\n            config={config.config}\n            onChange={onChange}\n            onDisplayFormatChange={onDisplayFormatChange}\n          />\n        );\n        break;\n      case 'brush':\n        template = <BrushConfig config={config.config} onChange={onChange} />;\n        break;\n      case 'geocoder':\n        template = <GeocoderConfig config={config.config} onChange={onChange} />;\n        break;\n\n      default:\n        break;\n    }\n    return (\n      <StyledInteractionPanel className=\"interaction-panel\">\n        <StyledPanelHeader className=\"interaction-panel__header\" onClick={togglePanelActive}>\n          <PanelHeaderContent className=\"interaction-panel__header__content\">\n            <div className=\"interaction-panel__header__icon icon\">\n              {IconComponent ? <IconComponent height=\"16px\" /> : null}\n            </div>\n            <div className=\"interaction-panel__header__title\">\n              <PanelHeaderTitle>\n                <FormattedMessage id={config.label} />\n              </PanelHeaderTitle>\n            </div>\n          </PanelHeaderContent>\n          <div className=\"interaction-panel__header__actions\">\n            <Switch\n              checked={config.enabled}\n              id={`${config.id}-toggle`}\n              onChange={toggleEnableConfig}\n              secondary\n            />\n          </div>\n        </StyledPanelHeader>\n        {config.enabled && template && (\n          <PanelContent className=\"interaction-panel__content\">{template}</PanelContent>\n        )}\n      </StyledInteractionPanel>\n    );\n  };\n\n  return InteractionPanel;\n}\n\nexport default InteractionPanelFactory;\n"],"mappings":";;;;;;AAAA;AACA;;AAEA,OAAOA,KAAK,IAAGC,QAAQ,EAA+BC,WAAW,QAAO,OAAO;AAC/E,OAAOC,MAAM,MAAM,mBAAmB;AACtC,OAAOC,MAAM,MAAM,qBAAqB;AACxC,OAAOC,kBAAkB,MAAM,gBAAgB;AAC/C,OAAOC,oBAAoB,MAAM,kBAAkB;AACnD,OAAOC,qBAAqB,MAAM,mBAAmB;AAQrD,SACEC,iBAAiB,EACjBC,gBAAgB,EAChBC,kBAAkB,EAClBC,YAAY,QACP,gCAAgC;AACvC,SAAQC,QAAQ,EAAEC,UAAU,EAAEC,WAAW,EAAEC,GAAG,QAAO,oBAAoB;AAEzE,SAAQC,gBAAgB,QAAO,yBAAyB;AAYxD,IAAMC,sBAAsB,GAAGd,MAAM,CAACe,GAAG,CAAAC,eAAA,KAAAA,eAAA,GAAAC,sBAAA,4DAGxC;AAEDC,uBAAuB,CAACC,IAAI,GAAG,CAAChB,oBAAoB,EAAED,kBAAkB,EAAEE,qBAAqB,CAAC;AAEhG,IAAMgB,wBAA4D,GAAG;EACnEC,OAAO,EAAEZ,QAAQ;EACjBa,QAAQ,EAAEV,GAAG;EACbW,KAAK,EAAEb,UAAU;EACjBc,UAAU,EAAEb;AACd,CAAC;AAED,SAASO,uBAAuBA,CAC9BO,aAAsD,EACtDC,WAAkD,EAClDC,cAAwD,EAClB;EACtC,IAAMC,gBAAiD,GAAG,SAApDA,gBAAiDA,CAAAC,IAAA,EAMjD;IAAA,IALJC,MAAM,GAAAD,IAAA,CAANC,MAAM;MACNC,cAAc,GAAAF,IAAA,CAAdE,cAAc;MACdC,QAAQ,GAAAH,IAAA,CAARG,QAAQ;MACRC,sBAAsB,GAAAJ,IAAA,CAAtBI,sBAAsB;MAAAC,qBAAA,GAAAL,IAAA,CACtBM,sBAAsB;MAAtBA,sBAAsB,GAAAD,qBAAA,cAAGd,wBAAwB,GAAAc,qBAAA;IAEjD,IAAAE,SAAA,GAA4CtC,QAAQ,CAAC,KAAK,CAAC;MAAAuC,UAAA,GAAAC,cAAA,CAAAF,SAAA;MAApDG,cAAc,GAAAF,UAAA;MAAEG,iBAAiB,GAAAH,UAAA;IAExC,IAAMI,aAAa,GAAG1C,WAAW,CAC/B,UAAA2C,OAAO,EAAI;MACTX,cAAc,CAAAY,aAAA,CAAAA,aAAA,KACTb,MAAM,GACNY,OAAO,CACX,CAAC;IACJ,CAAC,EACD,CAACX,cAAc,EAAED,MAAM,CACzB,CAAC;IAED,IAAMc,qBAAqB,GAAG7C,WAAW,CACvC,UAAC8C,MAAM,EAAEC,MAAM,EAAEC,aAAa,EAAK;MACjCd,sBAAsB,CAACY,MAAM,EAAAG,eAAA,KAAIF,MAAM,EAAGC,aAAa,CAAC,CAAC;IAC3D,CAAC,EACD,CAACd,sBAAsB,CACzB,CAAC;IAED,IAAMgB,iBAAiB,GAAGlD,WAAW,CAAC,YAAM;MAC1CyC,iBAAiB,CAAC,CAACD,cAAc,CAAC;IACpC,CAAC,EAAE,CAACC,iBAAiB,EAAED,cAAc,CAAC,CAAC;IAEvC,IAAOW,OAAO,GAAIpB,MAAM,CAAjBoB,OAAO;IACd,IAAMC,kBAAkB,GAAGpD,WAAW,CAAC,YAAM;MAC3C0C,aAAa,CAAC;QAACS,OAAO,EAAE,CAACA;MAAO,CAAC,CAAC;IACpC,CAAC,EAAE,CAACT,aAAa,EAAES,OAAO,CAAC,CAAC;IAE5B,IAAME,QAAQ,GAAGrD,WAAW,CAAC,UAAAsD,SAAS;MAAA,OAAIZ,aAAa,CAAC;QAACX,MAAM,EAAEuB;MAAS,CAAC,CAAC;IAAA,GAAE,CAACZ,aAAa,CAAC,CAAC;IAE9F,IAAMa,aAAa,GAAGnB,sBAAsB,CAACL,MAAM,CAACyB,EAAE,CAAC;IAEvD,IAAIC,QAA6B,GAAG,IAAI;IAExC,QAAQ1B,MAAM,CAACyB,EAAE;MACf,KAAK,SAAS;QACZC,QAAQ,gBACN3D,KAAA,CAAA4D,aAAA,CAAChC,aAAa;UACZO,QAAQ,EAAEA,QAAS;UACnBF,MAAM,EAAEA,MAAM,CAACA,MAAO;UACtBsB,QAAQ,EAAEA,QAAS;UACnBR,qBAAqB,EAAEA;QAAsB,CAC9C,CACF;QACD;MACF,KAAK,OAAO;QACVY,QAAQ,gBAAG3D,KAAA,CAAA4D,aAAA,CAAC/B,WAAW;UAACI,MAAM,EAAEA,MAAM,CAACA,MAAO;UAACsB,QAAQ,EAAEA;QAAS,CAAE,CAAC;QACrE;MACF,KAAK,UAAU;QACbI,QAAQ,gBAAG3D,KAAA,CAAA4D,aAAA,CAAC9B,cAAc;UAACG,MAAM,EAAEA,MAAM,CAACA,MAAO;UAACsB,QAAQ,EAAEA;QAAS,CAAE,CAAC;QACxE;MAEF;QACE;IACJ;IACA,oBACEvD,KAAA,CAAA4D,aAAA,CAAC3C,sBAAsB;MAAC4C,SAAS,EAAC;IAAmB,gBACnD7D,KAAA,CAAA4D,aAAA,CAACpD,iBAAiB;MAACqD,SAAS,EAAC,2BAA2B;MAACC,OAAO,EAAEV;IAAkB,gBAClFpD,KAAA,CAAA4D,aAAA,CAAClD,kBAAkB;MAACmD,SAAS,EAAC;IAAoC,gBAChE7D,KAAA,CAAA4D,aAAA;MAAKC,SAAS,EAAC;IAAsC,GAClDJ,aAAa,gBAAGzD,KAAA,CAAA4D,aAAA,CAACH,aAAa;MAACM,MAAM,EAAC;IAAM,CAAE,CAAC,GAAG,IAChD,CAAC,eACN/D,KAAA,CAAA4D,aAAA;MAAKC,SAAS,EAAC;IAAkC,gBAC/C7D,KAAA,CAAA4D,aAAA,CAACnD,gBAAgB,qBACfT,KAAA,CAAA4D,aAAA,CAAC5C,gBAAgB;MAAC0C,EAAE,EAAEzB,MAAM,CAAC+B;IAAM,CAAE,CACrB,CACf,CACa,CAAC,eACrBhE,KAAA,CAAA4D,aAAA;MAAKC,SAAS,EAAC;IAAoC,gBACjD7D,KAAA,CAAA4D,aAAA,CAACxD,MAAM;MACL6D,OAAO,EAAEhC,MAAM,CAACoB,OAAQ;MACxBK,EAAE,KAAAQ,MAAA,CAAKjC,MAAM,CAACyB,EAAE,YAAU;MAC1BH,QAAQ,EAAED,kBAAmB;MAC7Ba,SAAS;IAAA,CACV,CACE,CACY,CAAC,EACnBlC,MAAM,CAACoB,OAAO,IAAIM,QAAQ,iBACzB3D,KAAA,CAAA4D,aAAA,CAACjD,YAAY;MAACkD,SAAS,EAAC;IAA4B,GAAEF,QAAuB,CAEzD,CAAC;EAE7B,CAAC;EAED,OAAO5B,gBAAgB;AACzB;AAEA,eAAeV,uBAAuB","ignoreList":[]}

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

@@ -0,0 +1,157 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7;
+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) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useState } from 'react';
+import styled from 'styled-components';
+import classnames from 'classnames';
+import { CSS } from '@dnd-kit/utilities';
+import { ChickletButton } from '../../../common/item-selector/chickleted-input';
+import { Hash, Delete, VertDots } from '../../../common/icons';
+import DropdownList from '../../../common/item-selector/dropdown-list';
+import { FormattedMessage } from '@kepler.gl/localization';
+import { getFormatValue, getFormatLabels } from '@kepler.gl/utils';
+import TippyTooltip from '../../../common/tippy-tooltip';
+import useOnClickOutside from '../../../hooks/use-on-click-outside';
+var ChickletAddonWrapper = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  position: relative;\n"])));
+var ChickletAddon = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  margin-right: 4px;\n"])));
+var StyledPopover = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\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 = styled.div.attrs({
+  className: 'tooltip-chicklet__icon'
+})(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n  color: ", ";\n"])), function (props) {
+  return props.$status === hashStyles.SHOW ? props.theme.subtextColorActive : props.$status === hashStyles.ACTIVE ? props.theme.activeColor : props.theme.textColor;
+});
+var SortableStyledItem = styled.div(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n  transition: ", ";\n  transform: ", ";\n  &.sorting {\n    opacity: 0.3;\n    pointer-events: none;\n  }\n  &:hover {\n    .tooltip-chicklet__drag-handler {\n      opacity: 1;\n    }\n  }\n"])), function (props) {
+  return props.$transition;
+}, function (props) {
+  return props.$transform;
+});
+var StyledDragHandle = styled.div.attrs({
+  className: 'tooltip-chicklet__drag-handler'
+})(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["\n  display: flex;\n  align-items: center;\n  z-index: 1000;\n  opacity: 0;\n  margin-left: -5px;\n  &:hover {\n    cursor: move;\n    color: ", ";\n  }\n"])), function (props) {
+  return props.theme.tooltipVerticalLineColor;
+});
+var StyledTag = styled.span(_templateObject7 || (_templateObject7 = _taggedTemplateLiteral(["\n  margin-right: 5px;\n  text-overflow: ellipsis;\n  width: 100%;\n  overflow: hidden;\n  max-width: 160px;\n"])));
+function getFormatTooltip(formatLabels, format) {
+  if (!format) {
+    return null;
+  }
+  var formatLabel = formatLabels.find(function (fl) {
+    return getFormatValue(fl) === format;
+  });
+  if (formatLabel) {
+    return formatLabel.label;
+  }
+  return _typeof(format) === 'object' ? JSON.stringify(format, null, 2) : String(format);
+}
+
+// TODO: a factory should take other factories as input
+function TooltipChickletFactory(dataId, config, onChange, fields, onDisplayFormatChange) {
+  var TooltipChicklet = function TooltipChicklet(props) {
+    var disabled = props.disabled,
+      item = props.item,
+      displayOption = props.displayOption,
+      remove = props.remove,
+      attributes = props.attributes,
+      listeners = props.listeners,
+      setNodeRef = props.setNodeRef,
+      transform = props.transform,
+      transition = props.transition,
+      isDragging = props.isDragging;
+    var _useState = useState(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      show = _useState2[0],
+      setShow = _useState2[1];
+    var ref = useOnClickOutside(function () {
+      return setShow(false);
+    });
+    // const {show} = this.state;
+    var tooltipField = config.fieldsToShow[dataId].find(function (fieldToShow) {
+      return fieldToShow.name === item.name;
+    });
+    if (!tooltipField) {
+      return null;
+    }
+    var field = fields.find(function (f) {
+      return f.name === tooltipField.name;
+    });
+    if (!field) {
+      return null;
+    }
+    var formatLabels = getFormatLabels(fields, tooltipField.name);
+    var hasFormat = Boolean(field.displayFormat);
+    var selectionIndex = formatLabels.findIndex(function (fl) {
+      return getFormatValue(fl) === field.displayFormat;
+    });
+    var hashStyle = show ? hashStyles.SHOW : hasFormat ? hashStyles.ACTIVE : null;
+    return /*#__PURE__*/React.createElement(SortableStyledItem, _extends({
+      ref: setNodeRef,
+      className: classnames('sortable-layer-items', {
+        sorting: isDragging
+      }),
+      $transform: CSS.Translate.toString(transform),
+      $transition: transition || ''
+    }, attributes), /*#__PURE__*/React.createElement(ChickletButton, null, /*#__PURE__*/React.createElement(StyledDragHandle, listeners, /*#__PURE__*/React.createElement(VertDots, {
+      height: "12px"
+    })), /*#__PURE__*/React.createElement(StyledTag, {
+      title: displayOption(item)
+    }, displayOption(item)), formatLabels.length > 1 && /*#__PURE__*/React.createElement(ChickletAddonWrapper, null, /*#__PURE__*/React.createElement(TippyTooltip, {
+      placement: "top",
+      render: function render() {
+        return /*#__PURE__*/React.createElement("span", null, hasFormat ? getFormatTooltip(formatLabels, field.displayName) : /*#__PURE__*/React.createElement(FormattedMessage, {
+          id: 'fieldSelector.formatting'
+        }));
+      }
+    }, /*#__PURE__*/React.createElement(ChickletAddon, null, /*#__PURE__*/React.createElement(IconDiv, {
+      $status: hashStyle
+    }, /*#__PURE__*/React.createElement(Hash, {
+      height: "8px",
+      onClick: function onClick(e) {
+        e.stopPropagation();
+        setShow(Boolean(!show));
+      }
+    })))), show && /*#__PURE__*/React.createElement(StyledPopover, {
+      ref: ref
+    }, /*#__PURE__*/React.createElement(DropdownList, {
+      options: formatLabels,
+      selectionIndex: selectionIndex,
+      displayOption: function displayOption(option) {
+        return option.label;
+      },
+      onOptionSelected: function onOptionSelected(result, e) {
+        e.stopPropagation();
+        setShow(false);
+        var displayFormat = getFormatValue(result);
+        var oldFieldsToShow = config.fieldsToShow[dataId];
+        var fieldsToShow = oldFieldsToShow.map(function (fieldToShow) {
+          return fieldToShow.name === tooltipField.name ? {
+            name: tooltipField.name,
+            format: displayFormat
+          } : fieldToShow;
+        });
+        var newConfig = _objectSpread(_objectSpread({}, config), {}, {
+          fieldsToShow: _objectSpread(_objectSpread({}, config.fieldsToShow), {}, _defineProperty({}, dataId, fieldsToShow))
+        });
+        onChange(newConfig);
+        onDisplayFormatChange(dataId, field.name, displayFormat);
+      }
+    }))), /*#__PURE__*/React.createElement(Delete, {
+      height: "16px",
+      onClick: disabled ? null : remove
+    })));
+  };
+  return TooltipChicklet;
+}
+export default TooltipChickletFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useState","styled","classnames","CSS","ChickletButton","Hash","Delete","VertDots","DropdownList","FormattedMessage","getFormatValue","getFormatLabels","TippyTooltip","useOnClickOutside","ChickletAddonWrapper","div","_templateObject","_taggedTemplateLiteral","ChickletAddon","_templateObject2","StyledPopover","_templateObject3","hashStyles","SHOW","ACTIVE","IconDiv","attrs","className","_templateObject4","props","$status","theme","subtextColorActive","activeColor","textColor","SortableStyledItem","_templateObject5","$transition","$transform","StyledDragHandle","_templateObject6","tooltipVerticalLineColor","StyledTag","span","_templateObject7","getFormatTooltip","formatLabels","format","formatLabel","find","fl","label","_typeof","JSON","stringify","String","TooltipChickletFactory","dataId","config","onChange","fields","onDisplayFormatChange","TooltipChicklet","disabled","item","displayOption","remove","attributes","listeners","setNodeRef","transform","transition","isDragging","_useState","_useState2","_slicedToArray","show","setShow","ref","tooltipField","fieldsToShow","fieldToShow","name","field","f","hasFormat","Boolean","displayFormat","selectionIndex","findIndex","hashStyle","createElement","_extends","sorting","Translate","toString","height","title","length","placement","render","displayName","id","onClick","e","stopPropagation","options","option","onOptionSelected","result","oldFieldsToShow","map","newConfig","_objectSpread","_defineProperty"],"sources":["../../../../../src/side-panel/interaction-panel/tooltip-config/tooltip-chicklet.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useState, CSSProperties} from 'react';\nimport styled, {IStyledComponent} from 'styled-components';\nimport classnames from 'classnames';\nimport {DraggableAttributes} from '@dnd-kit/core';\nimport {CSS, Transform} from '@dnd-kit/utilities';\nimport {ChickletButton} from '../../../common/item-selector/chickleted-input';\nimport {Hash, Delete, VertDots} from '../../../common/icons';\nimport DropdownList from '../../../common/item-selector/dropdown-list';\nimport {FormattedMessage} from '@kepler.gl/localization';\nimport {TimeLabelFormat, TooltipFields} from '@kepler.gl/types';\nimport {getFormatValue, getFormatLabels} from '@kepler.gl/utils';\nimport TippyTooltip from '../../../common/tippy-tooltip';\nimport {TooltipFormat} from '@kepler.gl/constants';\nimport useOnClickOutside from '../../../hooks/use-on-click-outside';\nimport {BaseComponentProps} from '../../../types';\n\ninterface TooltipChickletProps {\n  disabled: boolean;\n  item: {name: string};\n  displayOption: (item: any) => string;\n  remove: any;\n\n  attributes: DraggableAttributes;\n  listeners: any;\n  setNodeRef: (node: HTMLElement | null) => void;\n  transform: Transform | null;\n  transition?: string;\n  isDragging: boolean;\n}\n\ntype TooltipConfig = {\n  fieldsToShow: {\n    [key: string]: {name: string; format: string | null}[];\n  };\n  compareMode: boolean;\n  compareType: string | null;\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' as const,\n  ACTIVE: 'ACTIVE' as const\n};\n\nexport type IconDivProps = BaseComponentProps & {\n  $status?: 'SHOW' | 'ACTIVE' | null;\n};\n\nconst IconDiv: IStyledComponent<'web', IconDivProps> = 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\nexport type SortableStyledItemProps = BaseComponentProps & {\n  $transition?: CSSProperties['transition'];\n  $transform?: CSSProperties['transform'];\n  ref: (node: HTMLElement | null) => void;\n};\nconst SortableStyledItem: IStyledComponent<\n  'web',\n  SortableStyledItemProps\n> = styled.div<SortableStyledItemProps>`\n  transition: ${props => props.$transition};\n  transform: ${props => props.$transform};\n  &.sorting {\n    opacity: 0.3;\n    pointer-events: none;\n  }\n  &:hover {\n    .tooltip-chicklet__drag-handler {\n      opacity: 1;\n    }\n  }\n`;\n\nconst StyledDragHandle = styled.div.attrs({\n  className: 'tooltip-chicklet__drag-handler'\n})`\n  display: flex;\n  align-items: center;\n  z-index: 1000;\n  opacity: 0;\n  margin-left: -5px;\n  &:hover {\n    cursor: move;\n    color: ${props => props.theme.tooltipVerticalLineColor};\n  }\n`;\n\nconst StyledTag = styled.span`\n  margin-right: 5px;\n  text-overflow: ellipsis;\n  width: 100%;\n  overflow: hidden;\n  max-width: 160px;\n`;\n\nfunction getFormatTooltip(formatLabels: TimeLabelFormat[], format: string | null) {\n  if (!format) {\n    return null;\n  }\n  const formatLabel = formatLabels.find(fl => getFormatValue(fl) === format);\n  if (formatLabel) {\n    return formatLabel.label;\n  }\n  return typeof format === 'object' ? JSON.stringify(format, null, 2) : String(format);\n}\n\n// TODO: a factory should take other factories as input\nfunction TooltipChickletFactory(\n  dataId: string,\n  config: TooltipConfig,\n  onChange: (cfg: TooltipConfig) => void,\n  fields: TooltipFields[],\n  onDisplayFormatChange\n): React.FC<TooltipChickletProps> {\n  const TooltipChicklet: React.FC<TooltipChickletProps> = (props: TooltipChickletProps) => {\n    const {\n      disabled,\n      item,\n      displayOption,\n      remove,\n      attributes,\n      listeners,\n      setNodeRef,\n      transform,\n      transition,\n      isDragging\n    } = props;\n\n    const [show, setShow] = useState(false);\n    const ref = useOnClickOutside<HTMLDivElement>(() => setShow(false));\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 field = fields.find(f => f.name === tooltipField.name);\n    if (!field) {\n      return null;\n    }\n    const formatLabels = getFormatLabels(fields, tooltipField.name);\n    const hasFormat = Boolean(field.displayFormat);\n    const selectionIndex = formatLabels.findIndex(fl => getFormatValue(fl) === field.displayFormat);\n    const hashStyle = show ? hashStyles.SHOW : hasFormat ? hashStyles.ACTIVE : null;\n\n    return (\n      <SortableStyledItem\n        ref={setNodeRef}\n        className={classnames('sortable-layer-items', {sorting: isDragging})}\n        $transform={CSS.Translate.toString(transform)}\n        $transition={transition || ''}\n        {...attributes}\n      >\n        <ChickletButton>\n          <StyledDragHandle {...listeners}>\n            <VertDots height=\"12px\" />\n          </StyledDragHandle>\n          <StyledTag title={displayOption(item)}>{displayOption(item)}</StyledTag>\n          {formatLabels.length > 1 && (\n            <ChickletAddonWrapper>\n              <TippyTooltip\n                placement=\"top\"\n                render={() => (\n                  <span>\n                    {hasFormat ? (\n                      getFormatTooltip(formatLabels, field.displayName)\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                        setShow(Boolean(!show));\n                      }}\n                    />\n                  </IconDiv>\n                </ChickletAddon>\n              </TippyTooltip>\n              {show && (\n                <StyledPopover ref={ref}>\n                  <DropdownList\n                    options={formatLabels}\n                    selectionIndex={selectionIndex}\n                    displayOption={option => (option as TooltipFormat).label}\n                    onOptionSelected={(result, e) => {\n                      e.stopPropagation();\n                      setShow(false);\n\n                      const displayFormat = getFormatValue(result);\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: displayFormat\n                            }\n                          : fieldToShow;\n                      });\n                      const newConfig = {\n                        ...config,\n                        fieldsToShow: {\n                          ...config.fieldsToShow,\n                          [dataId]: fieldsToShow\n                        }\n                      };\n                      onChange(newConfig);\n                      onDisplayFormatChange(dataId, field.name, displayFormat);\n                    }}\n                  />\n                </StyledPopover>\n              )}\n            </ChickletAddonWrapper>\n          )}\n          <Delete height=\"16px\" onClick={disabled ? null : remove} />\n        </ChickletButton>\n      </SortableStyledItem>\n    );\n  };\n\n  return TooltipChicklet;\n}\n\nexport default TooltipChickletFactory;\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,142 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3;
+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) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useCallback } from 'react';
+import styled from 'styled-components';
+import { injectIntl } from 'react-intl';
+import { FormattedMessage } from '@kepler.gl/localization';
+import { SidePanelSection, SBFlexboxNoMargin, Button, PanelLabel } from '../../common/styled-components';
+import DatasetTagFactory from '../common/dataset-tag';
+import TooltipChickletFactory from './tooltip-config/tooltip-chicklet';
+import Switch from '../../common/switch';
+import ItemSelector from '../../common/item-selector/item-selector';
+import { COMPARE_TYPES, GEOCODER_DATASET_NAME } from '@kepler.gl/constants';
+import FieldSelectorFactory from '../../common/field-selector';
+var TooltipConfigWrapper = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  .item-selector > div > div {\n    overflow: visible;\n  }\n"])));
+var ButtonWrapper = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\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 = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\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 = [DatasetTagFactory, FieldSelectorFactory];
+function TooltipConfigFactory(DatasetTag, FieldSelector) {
+  var DatasetTooltipConfig = function DatasetTooltipConfig(_ref) {
+    var config = _ref.config,
+      onChange = _ref.onChange,
+      dataset = _ref.dataset,
+      onDisplayFormatChange = _ref.onDisplayFormatChange;
+    var dataId = dataset.id;
+    var handleClick = useCallback(function () {
+      return onChange(_objectSpread(_objectSpread({}, config), {}, {
+        fieldsToShow: _objectSpread(_objectSpread({}, config.fieldsToShow), {}, _defineProperty({}, dataId, []))
+      }));
+    }, [config, dataId, onChange]);
+    var findSelectedHelper = useCallback(function (selected, tooltipFields) {
+      return selected.map(function (f) {
+        return tooltipFields.find(function (tooltipField) {
+          return tooltipField.name === f.name;
+        }) || {
+          name: f.name,
+          // default initial tooltip is null
+          format: null
+        };
+      });
+    }, []);
+    var handleSelect = useCallback(function (selected) {
+      var newConfig = _objectSpread(_objectSpread({}, config), {}, {
+        fieldsToShow: _objectSpread(_objectSpread({}, config.fieldsToShow), {}, _defineProperty({}, dataId, findSelectedHelper(selected, config.fieldsToShow[dataId])))
+      });
+      onChange(newConfig);
+    }, [config, dataId, onChange, findSelectedHelper]);
+    var handleReorderItems = useCallback(function (newOrder) {
+      return onChange(_objectSpread(_objectSpread({}, config), {}, {
+        fieldsToShow: _objectSpread(_objectSpread({}, config.fieldsToShow), {}, _defineProperty({}, dataId, newOrder))
+      }));
+    }, [config, dataId, onChange]);
+    return /*#__PURE__*/React.createElement(SidePanelSection, {
+      key: dataId
+    }, /*#__PURE__*/React.createElement(SBFlexboxNoMargin, null, /*#__PURE__*/React.createElement(DatasetTag, {
+      dataset: dataset
+    }), Boolean(config.fieldsToShow[dataId].length) && /*#__PURE__*/React.createElement(ButtonWrapper, null, /*#__PURE__*/React.createElement(Button, {
+      className: "clear-all",
+      onClick: handleClick,
+      width: "54px",
+      secondary: true
+    }, /*#__PURE__*/React.createElement(FormattedMessage, {
+      id: "fieldSelector.clearAll"
+    })))), /*#__PURE__*/React.createElement(FieldSelector, {
+      fields: dataset.fields,
+      value: config.fieldsToShow[dataId],
+      onSelect: handleSelect,
+      reorderItems: handleReorderItems,
+      closeOnSelect: false,
+      multiSelect: true,
+      inputTheme: "secondary",
+      CustomChickletComponent: TooltipChickletFactory(dataId, config, onChange, dataset.fields, onDisplayFormatChange)
+    }));
+  };
+  var TooltipConfig = function TooltipConfig(_ref2) {
+    var config = _ref2.config,
+      datasets = _ref2.datasets,
+      _onChange = _ref2.onChange,
+      onDisplayFormatChange = _ref2.onDisplayFormatChange,
+      intl = _ref2.intl;
+    var handleChange = useCallback(function (option) {
+      return _onChange(_objectSpread(_objectSpread({}, config), {}, {
+        compareType: option
+      }));
+    }, [config, _onChange]);
+    return /*#__PURE__*/React.createElement(TooltipConfigWrapper, null, Object.keys(config.fieldsToShow).map(function (dataId) {
+      return dataId === GEOCODER_DATASET_NAME ? null : /*#__PURE__*/React.createElement(DatasetTooltipConfig, {
+        key: dataId,
+        config: config,
+        onChange: _onChange,
+        dataset: datasets[dataId],
+        onDisplayFormatChange: onDisplayFormatChange
+      });
+    }), /*#__PURE__*/React.createElement(CompareSwitchWrapper, null, /*#__PURE__*/React.createElement(FormattedMessage, {
+      id: "compare.modeLabel"
+    }), /*#__PURE__*/React.createElement(Switch, {
+      checked: config.compareMode,
+      id: "compare-mode-toggle",
+      onChange: function onChange() {
+        var newConfig = _objectSpread(_objectSpread({}, config), {}, {
+          compareMode: !config.compareMode
+        });
+        _onChange(newConfig);
+      },
+      secondary: true
+    })), /*#__PURE__*/React.createElement(SidePanelSection, null, /*#__PURE__*/React.createElement(PanelLabel, null, /*#__PURE__*/React.createElement(FormattedMessage, {
+      id: "compare.typeLabel"
+    })), /*#__PURE__*/React.createElement(ItemSelector, {
+      disabled: !config.compareMode,
+      displayOption: function displayOption(d) {
+        return intl.formatMessage({
+          id: "compare.types.".concat(d)
+        });
+      },
+      selectedItems: config.compareType,
+      options: Object.values(COMPARE_TYPES),
+      multiSelect: false,
+      searchable: false,
+      inputTheme: 'secondary',
+      getOptionValue: function getOptionValue(d) {
+        return d;
+      },
+      onChange: handleChange
+    })));
+  };
+  return injectIntl(TooltipConfig);
+}
+export default TooltipConfigFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","styled","injectIntl","FormattedMessage","SidePanelSection","SBFlexboxNoMargin","Button","PanelLabel","DatasetTagFactory","TooltipChickletFactory","Switch","ItemSelector","COMPARE_TYPES","GEOCODER_DATASET_NAME","FieldSelectorFactory","TooltipConfigWrapper","div","_templateObject","_taggedTemplateLiteral","ButtonWrapper","_templateObject2","props","theme","subtextColor","textColor","CompareSwitchWrapper","_templateObject3","labelColor","inputFontSize","TooltipConfigFactory","deps","DatasetTag","FieldSelector","DatasetTooltipConfig","_ref","config","onChange","dataset","onDisplayFormatChange","dataId","id","handleClick","_objectSpread","fieldsToShow","_defineProperty","findSelectedHelper","selected","tooltipFields","map","f","find","tooltipField","name","format","handleSelect","newConfig","handleReorderItems","newOrder","createElement","key","Boolean","length","className","onClick","width","secondary","fields","value","onSelect","reorderItems","closeOnSelect","multiSelect","inputTheme","CustomChickletComponent","TooltipConfig","_ref2","datasets","intl","handleChange","option","compareType","Object","keys","checked","compareMode","disabled","displayOption","d","formatMessage","concat","selectedItems","options","values","searchable","getOptionValue"],"sources":["../../../../src/side-panel/interaction-panel/tooltip-config.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useCallback} 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  onDisplayFormatChange: (dataId, column, displayFormat) => void;\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  onDisplayFormatChange: (dataId, column, displayFormat) => void;\n};\n\nTooltipConfigFactory.deps = [DatasetTagFactory, FieldSelectorFactory];\nfunction TooltipConfigFactory(\n  DatasetTag: ReturnType<typeof DatasetTagFactory>,\n  FieldSelector: ReturnType<typeof FieldSelectorFactory>\n) {\n  const DatasetTooltipConfig = ({\n    config,\n    onChange,\n    dataset,\n    onDisplayFormatChange\n  }: DatasetTooltipConfigProps) => {\n    const dataId = dataset.id;\n\n    const handleClick = useCallback(\n      () =>\n        onChange({\n          ...config,\n          fieldsToShow: {\n            ...config.fieldsToShow,\n            [dataId]: []\n          }\n        }),\n      [config, dataId, onChange]\n    );\n\n    const findSelectedHelper = useCallback((selected, tooltipFields) => {\n      return selected.map(\n        f =>\n          tooltipFields.find(tooltipField => tooltipField.name === f.name) || {\n            name: f.name,\n            // default initial tooltip is null\n            format: null\n          }\n      );\n    }, []);\n\n    const handleSelect = useCallback(\n      selected => {\n        const newConfig: DatasetTooltipConfigProps['config'] = {\n          ...config,\n          fieldsToShow: {\n            ...config.fieldsToShow,\n            [dataId]: findSelectedHelper(selected, config.fieldsToShow[dataId])\n          }\n        };\n        onChange(newConfig);\n      },\n      [config, dataId, onChange, findSelectedHelper]\n    );\n\n    const handleReorderItems = useCallback(\n      newOrder =>\n        onChange({\n          ...config,\n          fieldsToShow: {\n            ...config.fieldsToShow,\n            [dataId]: newOrder\n          }\n        }),\n      [config, dataId, onChange]\n    );\n    return (\n      <SidePanelSection key={dataId}>\n        <SBFlexboxNoMargin>\n          <DatasetTag dataset={dataset} />\n          {Boolean(config.fieldsToShow[dataId].length) && (\n            <ButtonWrapper>\n              <Button className=\"clear-all\" onClick={handleClick} width=\"54px\" secondary>\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={handleSelect}\n          reorderItems={handleReorderItems}\n          closeOnSelect={false}\n          multiSelect\n          inputTheme=\"secondary\"\n          CustomChickletComponent={TooltipChickletFactory(\n            dataId,\n            config,\n            onChange,\n            dataset.fields,\n            onDisplayFormatChange\n          )}\n        />\n      </SidePanelSection>\n    );\n  };\n\n  const TooltipConfig = ({\n    config,\n    datasets,\n    onChange,\n    onDisplayFormatChange,\n    intl\n  }: TooltipConfigProps) => {\n    const handleChange = useCallback(\n      (option: string | number | boolean | object | null) =>\n        onChange({\n          ...config,\n          compareType: option as string | null\n        }),\n      [config, onChange]\n    );\n\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              onDisplayFormatChange={onDisplayFormatChange}\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={handleChange}\n          />\n        </SidePanelSection>\n      </TooltipConfigWrapper>\n    );\n  };\n\n  return injectIntl(TooltipConfig);\n}\n\nexport default TooltipConfigFactory;\n"],"mappings":"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","ignoreList":[]}