@kepler.gl/components 3.0.0-alpha.0

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

@@ -0,0 +1,19 @@
+import React from 'react';
+import LayerPanelFactory from './layer-panel';
+import { Layer, LayerClassesType } from '@kepler.gl/layers';
+import { Datasets } from '@kepler.gl/table';
+import { UIStateActions, VisStateActions } from '@kepler.gl/actions';
+declare type LayerListProps = {
+    datasets: Datasets;
+    layers: Layer[];
+    layerOrder: number[];
+    layerClasses: LayerClassesType;
+    isSortable?: boolean;
+    uiStateActions: typeof UIStateActions;
+    visStateActions: typeof VisStateActions;
+};
+declare function LayerListFactory(LayerPanel: ReturnType<typeof LayerPanelFactory>): React.FC<LayerListProps>;
+declare namespace LayerListFactory {
+    var deps: (typeof LayerPanelFactory)[];
+}
+export default LayerListFactory;

package/dist/side-panel/layer-panel/layer-list.js

@@ -0,0 +1,188 @@
+// 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 _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _reactSortableHoc = require("react-sortable-hoc");
+
+var _layerPanel = _interopRequireDefault(require("./layer-panel"));
+
+var _utils = require("@kepler.gl/utils");
+
+var _templateObject;
+
+// make sure the element is always visible while is being dragged
+// item being dragged is appended in body, here to reset its global style
+var SortableStyledItem = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  z-index: ", ";\n  &.sorting {\n    pointer-events: none;\n  }\n  &.sorting-layers .layer-panel__header {\n    background-color: ", ";\n    font-family: ", ";\n    font-weight: ", ";\n    font-size: ", ";\n    line-height: ", ";\n    *,\n    *:before,\n    *:after {\n      box-sizing: border-box;\n    }\n    .layer__drag-handle {\n      opacity: 1;\n      color: ", ";\n    }\n  }\n"])), function (props) {
+  return props.theme.dropdownWrapperZ + 1;
+}, function (props) {
+  return props.theme.panelBackgroundHover;
+}, function (props) {
+  return props.theme.fontFamily;
+}, function (props) {
+  return props.theme.fontWeight;
+}, function (props) {
+  return props.theme.fontSize;
+}, function (props) {
+  return props.theme.lineHeight;
+}, function (props) {
+  return props.theme.textColorHl;
+});
+
+LayerListFactory.deps = [_layerPanel["default"]];
+
+function LayerListFactory(LayerPanel) {
+  // By wrapping layer panel using a sortable element we don't have to implement the drag and drop logic into the panel itself;
+  // Developers can provide any layer panel implementation and it will still be sortable
+  var SortableItem = (0, _reactSortableHoc.SortableElement)(function (_ref) {
+    var children = _ref.children,
+        isSorting = _ref.isSorting;
+    return /*#__PURE__*/_react["default"].createElement(SortableStyledItem, {
+      className: (0, _classnames["default"])('sortable-layer-items', {
+        sorting: isSorting
+      })
+    }, children);
+  });
+  var WrappedSortableContainer = (0, _reactSortableHoc.SortableContainer)(function (_ref2) {
+    var children = _ref2.children;
+    return /*#__PURE__*/_react["default"].createElement("div", null, children);
+  });
+
+  var LayerList = function LayerList(props) {
+    var layers = props.layers,
+        datasets = props.datasets,
+        layerOrder = props.layerOrder,
+        uiStateActions = props.uiStateActions,
+        visStateActions = props.visStateActions,
+        layerClasses = props.layerClasses,
+        _props$isSortable = props.isSortable,
+        isSortable = _props$isSortable === void 0 ? true : _props$isSortable;
+    var openModal = uiStateActions.toggleModal;
+
+    var _useState = (0, _react.useState)(false),
+        _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+        isSorting = _useState2[0],
+        setIsSorting = _useState2[1];
+
+    var layerTypeOptions = (0, _react.useMemo)(function () {
+      return Object.keys(layerClasses).map(function (key) {
+        var layer = new layerClasses[key]();
+        return {
+          id: key,
+          label: layer.name,
+          icon: layer.layerIcon,
+          requireData: layer.requireData
+        };
+      });
+    }, [layerClasses]);
+    var layerActions = {
+      layerColorUIChange: visStateActions.layerColorUIChange,
+      layerConfigChange: visStateActions.layerConfigChange,
+      layerVisualChannelConfigChange: visStateActions.layerVisualChannelConfigChange,
+      layerTypeChange: visStateActions.layerTypeChange,
+      layerVisConfigChange: visStateActions.layerVisConfigChange,
+      layerTextLabelChange: visStateActions.layerTextLabelChange,
+      removeLayer: visStateActions.removeLayer,
+      duplicateLayer: visStateActions.duplicateLayer
+    };
+    var panelProps = {
+      datasets: datasets,
+      openModal: openModal,
+      layerTypeOptions: layerTypeOptions
+    };
+
+    var _handleSort = (0, _react.useCallback)(function (_ref3) {
+      var oldIndex = _ref3.oldIndex,
+          newIndex = _ref3.newIndex;
+      visStateActions.reorderLayer((0, _utils.arrayMove)(props.layerOrder, oldIndex, newIndex));
+      setIsSorting(false);
+    }, [props.layerOrder, visStateActions]);
+
+    var _onSortStart = (0, _react.useCallback)(function () {
+      setIsSorting(true);
+    }, []);
+
+    var _updateBeforeSortStart = (0, _react.useCallback)(function () {
+      (function (_ref4) {
+        var index = _ref4.index;
+        var layerIdx = layerOrder[index];
+
+        if (layers[layerIdx].config.isConfigActive) {
+          visStateActions.layerConfigChange(layers[layerIdx], {
+            isConfigActive: false
+          });
+        }
+      });
+    }, [layers, layerOrder, visStateActions]);
+
+    return isSortable ? /*#__PURE__*/_react["default"].createElement(WrappedSortableContainer, {
+      onSortEnd: _handleSort,
+      onSortStart: _onSortStart,
+      updateBeforeSortStart: _updateBeforeSortStart,
+      lockAxis: "y",
+      helperClass: "sorting-layers",
+      useDragHandle: true
+    }, layerOrder.map(function (layerIdx, index) {
+      return layers[layerIdx] && !layers[layerIdx].config.hidden && /*#__PURE__*/_react["default"].createElement(SortableItem, {
+        key: "layer-".concat(layerIdx),
+        index: index,
+        isSorting: isSorting
+      }, /*#__PURE__*/_react["default"].createElement(LayerPanel, (0, _extends2["default"])({}, panelProps, layerActions, {
+        key: layers[layerIdx].id,
+        idx: layerIdx,
+        layer: layers[layerIdx]
+      })));
+    })) : /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, layerOrder.map(function (layerIdx, index) {
+      return layers[layerIdx] && !layers[layerIdx].config.hidden && /*#__PURE__*/_react["default"].createElement(LayerPanel, (0, _extends2["default"])({}, panelProps, layerActions, {
+        key: layers[layerIdx].id,
+        idx: layerIdx,
+        layer: layers[layerIdx],
+        isDraggable: false
+      }));
+    }));
+  };
+
+  return LayerList;
+}
+
+var _default = LayerListFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/side-panel/layer-panel/layer-list.tsx"],"names":["SortableStyledItem","styled","div","props","theme","dropdownWrapperZ","panelBackgroundHover","fontFamily","fontWeight","fontSize","lineHeight","textColorHl","LayerListFactory","deps","LayerPanelFactory","LayerPanel","SortableItem","children","isSorting","sorting","WrappedSortableContainer","LayerList","layers","datasets","layerOrder","uiStateActions","visStateActions","layerClasses","isSortable","openModal","toggleModal","setIsSorting","layerTypeOptions","Object","keys","map","key","layer","id","label","name","icon","layerIcon","requireData","layerActions","layerColorUIChange","layerConfigChange","layerVisualChannelConfigChange","layerTypeChange","layerVisConfigChange","layerTextLabelChange","removeLayer","duplicateLayer","panelProps","_handleSort","oldIndex","newIndex","reorderLayer","_onSortStart","_updateBeforeSortStart","index","layerIdx","config","isConfigActive","hidden"],"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, {useCallback, useMemo, useState} from 'react';\nimport styled from 'styled-components';\nimport classnames from 'classnames';\nimport {SortableContainer, SortableElement} from 'react-sortable-hoc';\nimport LayerPanelFactory from './layer-panel';\nimport {Layer, LayerClassesType} from '@kepler.gl/layers';\nimport {Datasets} from '@kepler.gl/table';\nimport {arrayMove} from '@kepler.gl/utils';\nimport {UIStateActions, VisStateActions} from '@kepler.gl/actions';\n\ntype LayerListProps = {\n  datasets: Datasets;\n  layers: Layer[];\n  layerOrder: number[];\n  layerClasses: LayerClassesType;\n  isSortable?: boolean;\n  uiStateActions: typeof UIStateActions;\n  visStateActions: typeof VisStateActions;\n};\n\n// make sure the element is always visible while is being dragged\n// item being dragged is appended in body, here to reset its global style\nconst SortableStyledItem = styled.div`\n  z-index: ${props => props.theme.dropdownWrapperZ + 1};\n  &.sorting {\n    pointer-events: none;\n  }\n  &.sorting-layers .layer-panel__header {\n    background-color: ${props => props.theme.panelBackgroundHover};\n    font-family: ${props => props.theme.fontFamily};\n    font-weight: ${props => props.theme.fontWeight};\n    font-size: ${props => props.theme.fontSize};\n    line-height: ${props => props.theme.lineHeight};\n    *,\n    *:before,\n    *:after {\n      box-sizing: border-box;\n    }\n    .layer__drag-handle {\n      opacity: 1;\n      color: ${props => props.theme.textColorHl};\n    }\n  }\n`;\n\nLayerListFactory.deps = [LayerPanelFactory];\n\nfunction LayerListFactory(LayerPanel: ReturnType<typeof LayerPanelFactory>) {\n  // By wrapping layer panel using a sortable element we don't have to implement the drag and drop logic into the panel itself;\n  // Developers can provide any layer panel implementation and it will still be sortable\n  const SortableItem = SortableElement(({children, isSorting}) => {\n    return (\n      <SortableStyledItem className={classnames('sortable-layer-items', {sorting: isSorting})}>\n        {children}\n      </SortableStyledItem>\n    );\n  });\n\n  const WrappedSortableContainer = SortableContainer(({children}) => {\n    return <div>{children}</div>;\n  });\n\n  const LayerList: React.FC<LayerListProps> = props => {\n    const {\n      layers,\n      datasets,\n      layerOrder,\n      uiStateActions,\n      visStateActions,\n      layerClasses,\n      isSortable = true\n    } = props;\n    const {toggleModal: openModal} = uiStateActions;\n    const [isSorting, setIsSorting] = useState(false);\n    const layerTypeOptions = useMemo(\n      () =>\n        Object.keys(layerClasses).map(key => {\n          const layer = new layerClasses[key]();\n          return {\n            id: key,\n            label: layer.name,\n            icon: layer.layerIcon,\n            requireData: layer.requireData\n          };\n        }),\n      [layerClasses]\n    );\n\n    const layerActions = {\n      layerColorUIChange: visStateActions.layerColorUIChange,\n      layerConfigChange: visStateActions.layerConfigChange,\n      layerVisualChannelConfigChange: visStateActions.layerVisualChannelConfigChange,\n      layerTypeChange: visStateActions.layerTypeChange,\n      layerVisConfigChange: visStateActions.layerVisConfigChange,\n      layerTextLabelChange: visStateActions.layerTextLabelChange,\n      removeLayer: visStateActions.removeLayer,\n      duplicateLayer: visStateActions.duplicateLayer\n    };\n\n    const panelProps = {\n      datasets,\n      openModal,\n      layerTypeOptions\n    };\n\n    const _handleSort = useCallback(\n      ({oldIndex, newIndex}) => {\n        visStateActions.reorderLayer(arrayMove(props.layerOrder, oldIndex, newIndex));\n        setIsSorting(false);\n      },\n      [props.layerOrder, visStateActions]\n    );\n    const _onSortStart = useCallback(() => {\n      setIsSorting(true);\n    }, []);\n    const _updateBeforeSortStart = useCallback(() => {\n      ({index}) => {\n        const layerIdx = layerOrder[index];\n        if (layers[layerIdx].config.isConfigActive) {\n          visStateActions.layerConfigChange(layers[layerIdx], {isConfigActive: false});\n        }\n      };\n    }, [layers, layerOrder, visStateActions]);\n    return isSortable ? (\n      <WrappedSortableContainer\n        onSortEnd={_handleSort}\n        onSortStart={_onSortStart}\n        updateBeforeSortStart={_updateBeforeSortStart}\n        lockAxis=\"y\"\n        helperClass=\"sorting-layers\"\n        useDragHandle\n      >\n        {layerOrder.map(\n          (layerIdx, index) =>\n            layers[layerIdx] &&\n            !layers[layerIdx].config.hidden && (\n              <SortableItem key={`layer-${layerIdx}`} index={index} isSorting={isSorting}>\n                <LayerPanel\n                  {...panelProps}\n                  {...layerActions}\n                  key={layers[layerIdx].id}\n                  idx={layerIdx}\n                  layer={layers[layerIdx]}\n                />\n              </SortableItem>\n            )\n        )}\n      </WrappedSortableContainer>\n    ) : (\n      <>\n        {layerOrder.map(\n          (layerIdx, index) =>\n            layers[layerIdx] &&\n            !layers[layerIdx].config.hidden && (\n              <LayerPanel\n                {...panelProps}\n                {...layerActions}\n                key={layers[layerIdx].id}\n                idx={layerIdx}\n                layer={layers[layerIdx]}\n                isDraggable={false}\n              />\n            )\n        )}\n      </>\n    );\n  };\n  return LayerList;\n}\nexport default LayerListFactory;\n"]}

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

@@ -0,0 +1,63 @@
+import React, { ComponentType, MouseEventHandler, ChangeEventHandler } from 'react';
+import PanelHeaderActionFactory from '../panel-header-action';
+import { RGBColor } from '@kepler.gl/types';
+import { BaseProps } from '../../common/icons';
+declare type LayerLabelEditorProps = {
+    layerId: string;
+    label?: string;
+    onEdit: ChangeEventHandler;
+    onFocus: ChangeEventHandler;
+    onBlur: ChangeEventHandler;
+};
+declare type LayerTitleSectionProps = {
+    layerType?: string | null;
+    layerId: string;
+    label?: string;
+    onUpdateLayerLabel: ChangeEventHandler;
+    onFocus: ChangeEventHandler;
+    onBlur: ChangeEventHandler;
+};
+declare type LayerPanelHeaderProps = {
+    layerId: string;
+    isVisible: boolean;
+    onToggleVisibility: MouseEventHandler;
+    onUpdateLayerLabel: ChangeEventHandler;
+    onToggleEnableConfig: MouseEventHandler;
+    onRemoveLayer: MouseEventHandler;
+    onDuplicateLayer: MouseEventHandler;
+    isConfigActive: boolean;
+    showRemoveLayer?: boolean;
+    label?: string;
+    layerType?: string | null;
+    allowDuplicate?: boolean;
+    isDragNDropEnabled?: boolean;
+    warning?: boolean;
+    labelRCGColorValues?: RGBColor | null;
+    actionIcons?: {
+        remove: ComponentType<Partial<BaseProps>>;
+        visible: ComponentType<Partial<BaseProps>>;
+        hidden: ComponentType<Partial<BaseProps>>;
+        enableConfig: ComponentType<Partial<BaseProps>>;
+        resetIsValid: ComponentType<Partial<BaseProps>>;
+        duplicate: ComponentType<Partial<BaseProps>>;
+    };
+};
+export declare const defaultProps: {
+    isDragNDropEnabled: boolean;
+    showRemoveLayer: boolean;
+};
+export declare const DragHandle: React.ComponentClass<{
+    className: any;
+    children: any;
+}, any>;
+export declare const LayerLabelEditor: React.FC<LayerLabelEditorProps>;
+export declare function LayerTitleSectionFactory(): React.FC<LayerTitleSectionProps>;
+export declare const HeaderWarning: ({ warning, id }: {
+    warning: any;
+    id: any;
+}) => JSX.Element;
+declare function LayerPanelHeaderFactory(LayerTitleSection: ReturnType<typeof LayerTitleSectionFactory>, PanelHeaderAction: ReturnType<typeof PanelHeaderActionFactory>): React.FC<LayerPanelHeaderProps>;
+declare namespace LayerPanelHeaderFactory {
+    var deps: (typeof PanelHeaderActionFactory | typeof LayerTitleSectionFactory)[];
+}
+export default LayerPanelHeaderFactory;

package/dist/side-panel/layer-panel/layer-panel-header.js

@@ -0,0 +1,291 @@
+// 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.LayerTitleSectionFactory = LayerTitleSectionFactory;
+exports["default"] = exports.HeaderWarning = exports.LayerLabelEditor = exports.DragHandle = exports.defaultProps = void 0;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _styledComponents = _interopRequireWildcard(require("styled-components"));
+
+var _reactSortableHoc = require("react-sortable-hoc");
+
+var _panelHeaderAction = _interopRequireDefault(require("../panel-header-action"));
+
+var _styledComponents2 = require("../../common/styled-components");
+
+var _icons = require("../../common/icons");
+
+var _localization = require("@kepler.gl/localization");
+
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7, _templateObject8;
+
+var defaultProps = {
+  isDragNDropEnabled: true,
+  showRemoveLayer: true
+};
+exports.defaultProps = defaultProps;
+
+var getBorderCss = function getBorderCss(status) {
+  return (0, _styledComponents.css)(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n    border-top: 2px solid ", ";\n    border-bottom: 2px solid ", ";\n    border-right: 2px solid ", ";\n  "])), function (_ref) {
+    var theme = _ref.theme;
+    return theme.notificationColors[status];
+  }, function (_ref2) {
+    var theme = _ref2.theme;
+    return theme.notificationColors[status];
+  }, function (_ref3) {
+    var theme = _ref3.theme;
+    return theme.notificationColors[status];
+  });
+};
+
+var StyledLayerPanelHeader = (0, _styledComponents["default"])(_styledComponents2.StyledPanelHeader)(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  height: ", "px;\n  position: relative;\n  align-items: stretch;\n\n  .layer__remove-layer {\n    opacity: 0;\n  }\n\n  .layer__drag-handle__placeholder {\n    height: 20px;\n    padding: 10px;\n  }\n\n  ", "\n\n  :hover {\n    cursor: pointer;\n    background-color: ", ";\n\n    .layer__drag-handle {\n      opacity: 1;\n    }\n\n    .layer__remove-layer {\n      opacity: 1;\n    }\n  }\n"])), function (props) {
+  return props.theme.layerPanelHeaderHeight;
+}, function (props) {
+  return props.warning ? getBorderCss('warning') : '';
+}, function (props) {
+  return props.theme.panelBackgroundHover;
+});
+
+var HeaderLabelSection = _styledComponents["default"].div(_templateObject3 || (_templateObject3 = (0, _taggedTemplateLiteral2["default"])(["\n  display: flex;\n  color: ", ";\n  flex-grow: 1;\n  align-items: stretch;\n  // leave space for eye and collapse icon\n  padding-right: 50px;\n"])), function (props) {
+  return props.theme.textColor;
+});
+
+var HeaderActionSection = _styledComponents["default"].div(_templateObject4 || (_templateObject4 = (0, _taggedTemplateLiteral2["default"])(["\n  display: flex;\n  position: absolute;\n  height: 100%;\n  align-items: stretch;\n  right: 10px;\n  pointer-events: ", ";\n  :hover {\n    .layer-panel__header__actions__hidden {\n      opacity: 1;\n      background-color: ", ";\n    }\n  }\n"])), function (props) {
+  return props.isEditingLabel ? 'none' : 'all';
+}, function (props) {
+  return props.theme.panelBackgroundHover;
+});
+
+// Hiden actions only show up on hover
+var StyledPanelHeaderHiddenActions = _styledComponents["default"].div.attrs({
+  className: 'layer-panel__header__actions__hidden'
+})(_templateObject5 || (_templateObject5 = (0, _taggedTemplateLiteral2["default"])(["\n  opacity: 0;\n  display: flex;\n  align-items: center;\n  background-color: ", ";\n  transition: opacity 0.4s ease, background-color 0.4s ease;\n\n  :hover {\n    opacity: 1;\n  }\n"])), function (props) {
+  return props.isConfigActive ? props.theme.panelBackgroundHover : props.theme.panelBackground;
+});
+
+var StyledDragHandle = _styledComponents["default"].div(_templateObject6 || (_templateObject6 = (0, _taggedTemplateLiteral2["default"])(["\n  display: flex;\n  align-items: center;\n  opacity: 0;\n  z-index: 1000;\n\n  :hover {\n    cursor: move;\n    opacity: 1;\n    color: ", ";\n  }\n"])), function (props) {
+  return props.theme.textColorHl;
+});
+
+var DragHandle = (0, _reactSortableHoc.SortableHandle)(function (_ref4) {
+  var className = _ref4.className,
+      children = _ref4.children;
+  return /*#__PURE__*/_react["default"].createElement(StyledDragHandle, {
+    className: className
+  }, children);
+});
+exports.DragHandle = DragHandle;
+
+var LayerLabelEditor = function LayerLabelEditor(_ref5) {
+  var layerId = _ref5.layerId,
+      label = _ref5.label,
+      onEdit = _ref5.onEdit,
+      onFocus = _ref5.onFocus,
+      onBlur = _ref5.onBlur;
+  return /*#__PURE__*/_react["default"].createElement(_styledComponents2.InlineInput, {
+    type: "text",
+    className: "layer__title__editor",
+    value: label,
+    onClick: function onClick(e) {
+      e.stopPropagation();
+    },
+    onChange: onEdit,
+    onFocus: onFocus,
+    onBlur: onBlur,
+    id: "".concat(layerId, ":input-layer-label")
+  });
+};
+
+exports.LayerLabelEditor = LayerLabelEditor;
+
+function LayerTitleSectionFactory() {
+  var StyledLayerTitleSection = _styledComponents["default"].div(_templateObject7 || (_templateObject7 = (0, _taggedTemplateLiteral2["default"])(["\n    margin-left: 4px;\n    flex-grow: 1;\n    align-items: center;\n    display: flex;\n    .layer__title__inner {\n      flex-grow: 1;\n    }\n\n    .layer__title__type {\n      color: ", ";\n      font-size: 10px;\n      line-height: 12px;\n      letter-spacing: 0.37px;\n      text-transform: capitalize;\n    }\n  "])), function (props) {
+    return props.theme.subtextColor;
+  });
+
+  var LayerTitleSection = function LayerTitleSection(_ref6) {
+    var layerType = _ref6.layerType,
+        layerId = _ref6.layerId,
+        label = _ref6.label,
+        onUpdateLayerLabel = _ref6.onUpdateLayerLabel,
+        onFocus = _ref6.onFocus,
+        onBlur = _ref6.onBlur;
+    return /*#__PURE__*/_react["default"].createElement(StyledLayerTitleSection, {
+      className: "layer__title"
+    }, /*#__PURE__*/_react["default"].createElement("div", null, /*#__PURE__*/_react["default"].createElement(LayerLabelEditor, {
+      layerId: layerId,
+      label: label,
+      onEdit: onUpdateLayerLabel,
+      onFocus: onFocus,
+      onBlur: onBlur
+    }), /*#__PURE__*/_react["default"].createElement("div", {
+      className: "layer__title__type"
+    }, layerType && /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+      id: "layer.type.".concat(layerType.toLowerCase())
+    }))));
+  };
+
+  return LayerTitleSection;
+}
+
+var StyledHeaderWaring = _styledComponents["default"].div(_templateObject8 || (_templateObject8 = (0, _taggedTemplateLiteral2["default"])(["\n  position: absolute;\n  right: -9px;\n  top: calc(50% - 9px);\n  color: ", ";\n"])), function (_ref7) {
+  var theme = _ref7.theme;
+  return theme.notificationColors.warning;
+});
+
+var HeaderWarning = function HeaderWarning(_ref8) {
+  var warning = _ref8.warning,
+      id = _ref8.id;
+  return /*#__PURE__*/_react["default"].createElement(StyledHeaderWaring, null, /*#__PURE__*/_react["default"].createElement(_icons.WarningSign, {
+    "data-tip": true,
+    "data-for": "layer-".concat(id, "-warning"),
+    height: "16px"
+  }), /*#__PURE__*/_react["default"].createElement(_styledComponents2.Tooltip, {
+    id: "layer-".concat(id, "-warning"),
+    type: "warning",
+    effect: "solid",
+    textColor: "black"
+  }, warning));
+};
+
+exports.HeaderWarning = HeaderWarning;
+LayerPanelHeaderFactory.deps = [LayerTitleSectionFactory, _panelHeaderAction["default"]];
+var defaultActionIcons = {
+  remove: _icons.Trash,
+  visible: _icons.EyeSeen,
+  hidden: _icons.EyeUnseen,
+  enableConfig: _icons.ArrowDown,
+  duplicate: _icons.Copy
+};
+
+function LayerPanelHeaderFactory(LayerTitleSection, PanelHeaderAction) {
+  var LayerPanelHeader = function LayerPanelHeader(_ref9) {
+    var isConfigActive = _ref9.isConfigActive,
+        allowDuplicate = _ref9.allowDuplicate,
+        isDragNDropEnabled = _ref9.isDragNDropEnabled,
+        isVisible = _ref9.isVisible,
+        warning = _ref9.warning,
+        label = _ref9.label,
+        layerId = _ref9.layerId,
+        layerType = _ref9.layerType,
+        labelRCGColorValues = _ref9.labelRCGColorValues,
+        onToggleVisibility = _ref9.onToggleVisibility,
+        onUpdateLayerLabel = _ref9.onUpdateLayerLabel,
+        onToggleEnableConfig = _ref9.onToggleEnableConfig,
+        onDuplicateLayer = _ref9.onDuplicateLayer,
+        onRemoveLayer = _ref9.onRemoveLayer,
+        showRemoveLayer = _ref9.showRemoveLayer,
+        _ref9$actionIcons = _ref9.actionIcons,
+        actionIcons = _ref9$actionIcons === void 0 ? defaultActionIcons : _ref9$actionIcons;
+
+    var _useState = (0, _react.useState)(false),
+        _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+        isEditingLabel = _useState2[0],
+        setIsEditingLabel = _useState2[1];
+
+    return /*#__PURE__*/_react["default"].createElement(StyledLayerPanelHeader, {
+      className: (0, _classnames["default"])('layer-panel__header', {
+        'sort--handle': !isConfigActive
+      }),
+      warning: warning,
+      active: isConfigActive,
+      labelRCGColorValues: labelRCGColorValues,
+      onClick: onToggleEnableConfig
+    }, warning ? /*#__PURE__*/_react["default"].createElement(HeaderWarning, {
+      warning: warning,
+      id: layerId
+    }) : null, /*#__PURE__*/_react["default"].createElement(HeaderLabelSection, {
+      className: "layer-panel__header__content"
+    }, isDragNDropEnabled ? /*#__PURE__*/_react["default"].createElement(DragHandle, {
+      className: "layer__drag-handle"
+    }, /*#__PURE__*/_react["default"].createElement(_icons.VertDots, {
+      height: "20px"
+    })) : /*#__PURE__*/_react["default"].createElement("div", {
+      className: "layer__drag-handle__placeholder"
+    }), /*#__PURE__*/_react["default"].createElement(LayerTitleSection, {
+      layerId: layerId,
+      label: label,
+      onUpdateLayerLabel: onUpdateLayerLabel,
+      layerType: layerType,
+      onFocus: function onFocus() {
+        setIsEditingLabel(true);
+      },
+      onBlur: function onBlur() {
+        setIsEditingLabel(false);
+      }
+    })), /*#__PURE__*/_react["default"].createElement(HeaderActionSection, {
+      className: "layer-panel__header__actions",
+      isEditingLabel: isEditingLabel
+    }, /*#__PURE__*/_react["default"].createElement(StyledPanelHeaderHiddenActions, {
+      isConfigActive: isConfigActive
+    }, showRemoveLayer ? /*#__PURE__*/_react["default"].createElement(PanelHeaderAction, {
+      className: "layer__remove-layer",
+      id: layerId,
+      tooltip: 'tooltip.removeLayer',
+      onClick: onRemoveLayer,
+      tooltipType: "error",
+      IconComponent: actionIcons.remove
+    }) : null, /*#__PURE__*/_react["default"].createElement(PanelHeaderAction, {
+      className: "layer__duplicate",
+      id: layerId,
+      tooltip: 'tooltip.duplicateLayer',
+      onClick: onDuplicateLayer,
+      IconComponent: actionIcons.duplicate,
+      disabled: !allowDuplicate
+    })), /*#__PURE__*/_react["default"].createElement(PanelHeaderAction, {
+      className: "layer__visibility-toggle",
+      id: layerId,
+      tooltip: isVisible ? 'tooltip.hideLayer' : 'tooltip.showLayer',
+      onClick: onToggleVisibility,
+      IconComponent: isVisible ? actionIcons.visible : actionIcons.hidden
+    }), /*#__PURE__*/_react["default"].createElement(PanelHeaderAction, {
+      className: (0, _classnames["default"])('layer__enable-config ', {
+        'is-open': isConfigActive
+      }),
+      id: layerId,
+      tooltip: 'tooltip.layerSettings',
+      onClick: onToggleEnableConfig,
+      IconComponent: actionIcons.enableConfig
+    })));
+  };
+
+  LayerPanelHeader.defaultProps = defaultProps;
+  return LayerPanelHeader;
+}
+
+var _default = LayerPanelHeaderFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/side-panel/layer-panel/layer-panel-header.tsx"],"names":["defaultProps","isDragNDropEnabled","showRemoveLayer","getBorderCss","status","css","theme","notificationColors","StyledLayerPanelHeader","StyledPanelHeader","props","layerPanelHeaderHeight","warning","panelBackgroundHover","HeaderLabelSection","styled","div","textColor","HeaderActionSection","isEditingLabel","StyledPanelHeaderHiddenActions","attrs","className","isConfigActive","panelBackground","StyledDragHandle","textColorHl","DragHandle","children","LayerLabelEditor","layerId","label","onEdit","onFocus","onBlur","e","stopPropagation","LayerTitleSectionFactory","StyledLayerTitleSection","subtextColor","LayerTitleSection","layerType","onUpdateLayerLabel","toLowerCase","StyledHeaderWaring","HeaderWarning","id","LayerPanelHeaderFactory","deps","PanelHeaderActionFactory","defaultActionIcons","remove","Trash","visible","EyeSeen","hidden","EyeUnseen","enableConfig","ArrowDown","duplicate","Copy","PanelHeaderAction","LayerPanelHeader","allowDuplicate","isVisible","labelRCGColorValues","onToggleVisibility","onToggleEnableConfig","onDuplicateLayer","onRemoveLayer","actionIcons","setIsEditingLabel"],"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, {\n  useState,\n  ComponentType,\n  MouseEventHandler,\n  MouseEvent,\n  ChangeEventHandler\n} from 'react';\nimport classnames from 'classnames';\nimport styled, {css} from 'styled-components';\nimport {SortableHandle} from 'react-sortable-hoc';\nimport PanelHeaderActionFactory from '../panel-header-action';\nimport {Tooltip} from '../../common/styled-components';\nimport {\n  Copy,\n  ArrowDown,\n  EyeSeen,\n  EyeUnseen,\n  Trash,\n  VertDots,\n  WarningSign\n} from '../../common/icons';\n\nimport {InlineInput, StyledPanelHeader} from '../../common/styled-components';\nimport {FormattedMessage} from '@kepler.gl/localization';\nimport {RGBColor} from '@kepler.gl/types';\nimport {BaseProps} from '../../common/icons';\n\ntype LayerLabelEditorProps = {\n  layerId: string;\n  label?: string;\n  onEdit: ChangeEventHandler;\n  onFocus: ChangeEventHandler;\n  onBlur: ChangeEventHandler;\n};\n\ntype LayerTitleSectionProps = {\n  layerType?: string | null;\n  layerId: string;\n  label?: string;\n  onUpdateLayerLabel: ChangeEventHandler;\n  onFocus: ChangeEventHandler;\n  onBlur: ChangeEventHandler;\n};\n\ntype LayerPanelHeaderProps = {\n  layerId: string;\n  isVisible: boolean;\n  onToggleVisibility: MouseEventHandler;\n  onUpdateLayerLabel: ChangeEventHandler;\n  onToggleEnableConfig: MouseEventHandler;\n  onRemoveLayer: MouseEventHandler;\n  onDuplicateLayer: MouseEventHandler;\n  isConfigActive: boolean;\n  showRemoveLayer?: boolean;\n  label?: string;\n  layerType?: string | null;\n  allowDuplicate?: boolean;\n  isDragNDropEnabled?: boolean;\n  warning?: boolean;\n  labelRCGColorValues?: RGBColor | null;\n  actionIcons?: {\n    remove: ComponentType<Partial<BaseProps>>;\n    visible: ComponentType<Partial<BaseProps>>;\n    hidden: ComponentType<Partial<BaseProps>>;\n    enableConfig: ComponentType<Partial<BaseProps>>;\n    resetIsValid: ComponentType<Partial<BaseProps>>;\n    duplicate: ComponentType<Partial<BaseProps>>;\n  };\n};\n\nexport const defaultProps = {\n  isDragNDropEnabled: true,\n  showRemoveLayer: true\n};\n\nconst getBorderCss = status =>\n  css`\n    border-top: 2px solid ${({theme}) => theme.notificationColors[status]};\n    border-bottom: 2px solid ${({theme}) => theme.notificationColors[status]};\n    border-right: 2px solid ${({theme}) => theme.notificationColors[status]};\n  `;\n\nconst StyledLayerPanelHeader = styled(StyledPanelHeader)`\n  height: ${props => props.theme.layerPanelHeaderHeight}px;\n  position: relative;\n  align-items: stretch;\n\n  .layer__remove-layer {\n    opacity: 0;\n  }\n\n  .layer__drag-handle__placeholder {\n    height: 20px;\n    padding: 10px;\n  }\n\n  ${props => (props.warning ? getBorderCss('warning') : '')}\n\n  :hover {\n    cursor: pointer;\n    background-color: ${props => props.theme.panelBackgroundHover};\n\n    .layer__drag-handle {\n      opacity: 1;\n    }\n\n    .layer__remove-layer {\n      opacity: 1;\n    }\n  }\n`;\n\nconst HeaderLabelSection = styled.div`\n  display: flex;\n  color: ${props => props.theme.textColor};\n  flex-grow: 1;\n  align-items: stretch;\n  // leave space for eye and collapse icon\n  padding-right: 50px;\n`;\n\ntype HeaderActionSectionProps = {\n  isEditingLabel: boolean;\n};\n\nconst HeaderActionSection = styled.div<HeaderActionSectionProps>`\n  display: flex;\n  position: absolute;\n  height: 100%;\n  align-items: stretch;\n  right: 10px;\n  pointer-events: ${props => (props.isEditingLabel ? 'none' : 'all')};\n  :hover {\n    .layer-panel__header__actions__hidden {\n      opacity: 1;\n      background-color: ${props => props.theme.panelBackgroundHover};\n    }\n  }\n`;\n\ntype StyledPanelHeaderHiddenActionsProps = {\n  isConfigActive: LayerPanelHeaderProps['isConfigActive'];\n};\n\n// Hiden actions only show up on hover\nconst StyledPanelHeaderHiddenActions = styled.div.attrs({\n  className: 'layer-panel__header__actions__hidden'\n})<StyledPanelHeaderHiddenActionsProps>`\n  opacity: 0;\n  display: flex;\n  align-items: center;\n  background-color: ${props =>\n    props.isConfigActive ? props.theme.panelBackgroundHover : props.theme.panelBackground};\n  transition: opacity 0.4s ease, background-color 0.4s ease;\n\n  :hover {\n    opacity: 1;\n  }\n`;\n\nconst StyledDragHandle = styled.div`\n  display: flex;\n  align-items: center;\n  opacity: 0;\n  z-index: 1000;\n\n  :hover {\n    cursor: move;\n    opacity: 1;\n    color: ${props => props.theme.textColorHl};\n  }\n`;\n\nexport const DragHandle = SortableHandle(({className, children}) => (\n  <StyledDragHandle className={className}>{children}</StyledDragHandle>\n));\n\nexport const LayerLabelEditor: React.FC<LayerLabelEditorProps> = ({\n  layerId,\n  label,\n  onEdit,\n  onFocus,\n  onBlur\n}) => (\n  <InlineInput\n    type=\"text\"\n    className=\"layer__title__editor\"\n    value={label}\n    onClick={(e: MouseEvent) => {\n      e.stopPropagation();\n    }}\n    onChange={onEdit}\n    onFocus={onFocus}\n    onBlur={onBlur}\n    id={`${layerId}:input-layer-label`}\n  />\n);\n\nexport function LayerTitleSectionFactory() {\n  const StyledLayerTitleSection = styled.div`\n    margin-left: 4px;\n    flex-grow: 1;\n    align-items: center;\n    display: flex;\n    .layer__title__inner {\n      flex-grow: 1;\n    }\n\n    .layer__title__type {\n      color: ${props => props.theme.subtextColor};\n      font-size: 10px;\n      line-height: 12px;\n      letter-spacing: 0.37px;\n      text-transform: capitalize;\n    }\n  `;\n  const LayerTitleSection: React.FC<LayerTitleSectionProps> = ({\n    layerType,\n    layerId,\n    label,\n    onUpdateLayerLabel,\n    onFocus,\n    onBlur\n  }) => (\n    <StyledLayerTitleSection className=\"layer__title\">\n      <div>\n        <LayerLabelEditor\n          layerId={layerId}\n          label={label}\n          onEdit={onUpdateLayerLabel}\n          onFocus={onFocus}\n          onBlur={onBlur}\n        />\n        <div className=\"layer__title__type\">\n          {layerType && <FormattedMessage id={`layer.type.${layerType.toLowerCase()}`} />}\n        </div>\n      </div>\n    </StyledLayerTitleSection>\n  );\n  return LayerTitleSection;\n}\n\nconst StyledHeaderWaring = styled.div`\n  position: absolute;\n  right: -9px;\n  top: calc(50% - 9px);\n  color: ${({theme}) => theme.notificationColors.warning};\n`;\n\nexport const HeaderWarning = ({warning, id}) => (\n  <StyledHeaderWaring>\n    <WarningSign data-tip data-for={`layer-${id}-warning`} height=\"16px\" />\n    <Tooltip id={`layer-${id}-warning`} type=\"warning\" effect=\"solid\" textColor=\"black\">\n      {warning}\n    </Tooltip>\n  </StyledHeaderWaring>\n);\nLayerPanelHeaderFactory.deps = [LayerTitleSectionFactory, PanelHeaderActionFactory];\n\nconst defaultActionIcons = {\n  remove: Trash,\n  visible: EyeSeen,\n  hidden: EyeUnseen,\n  enableConfig: ArrowDown,\n  duplicate: Copy\n};\n\nfunction LayerPanelHeaderFactory(\n  LayerTitleSection: ReturnType<typeof LayerTitleSectionFactory>,\n  PanelHeaderAction: ReturnType<typeof PanelHeaderActionFactory>\n) {\n  const LayerPanelHeader: React.FC<LayerPanelHeaderProps> = ({\n    isConfigActive,\n    allowDuplicate,\n    isDragNDropEnabled,\n    isVisible,\n    warning,\n    label,\n    layerId,\n    layerType,\n    labelRCGColorValues,\n    onToggleVisibility,\n    onUpdateLayerLabel,\n    onToggleEnableConfig,\n    onDuplicateLayer,\n    onRemoveLayer,\n    showRemoveLayer,\n    actionIcons = defaultActionIcons\n  }) => {\n    const [isEditingLabel, setIsEditingLabel] = useState(false);\n\n    return (\n      <StyledLayerPanelHeader\n        className={classnames('layer-panel__header', {\n          'sort--handle': !isConfigActive\n        })}\n        warning={warning}\n        active={isConfigActive}\n        labelRCGColorValues={labelRCGColorValues}\n        onClick={onToggleEnableConfig}\n      >\n        {warning ? <HeaderWarning warning={warning} id={layerId} /> : null}\n        <HeaderLabelSection className=\"layer-panel__header__content\">\n          {isDragNDropEnabled ? (\n            <DragHandle className=\"layer__drag-handle\">\n              <VertDots height=\"20px\" />\n            </DragHandle>\n          ) : (\n            <div className=\"layer__drag-handle__placeholder\" />\n          )}\n          <LayerTitleSection\n            layerId={layerId}\n            label={label}\n            onUpdateLayerLabel={onUpdateLayerLabel}\n            layerType={layerType}\n            onFocus={() => {\n              setIsEditingLabel(true);\n            }}\n            onBlur={() => {\n              setIsEditingLabel(false);\n            }}\n          />\n        </HeaderLabelSection>\n        <HeaderActionSection\n          className=\"layer-panel__header__actions\"\n          isEditingLabel={isEditingLabel}\n        >\n          <StyledPanelHeaderHiddenActions isConfigActive={isConfigActive}>\n            {showRemoveLayer ? (\n              <PanelHeaderAction\n                className=\"layer__remove-layer\"\n                id={layerId}\n                tooltip={'tooltip.removeLayer'}\n                onClick={onRemoveLayer}\n                tooltipType=\"error\"\n                IconComponent={actionIcons.remove}\n              />\n            ) : null}\n            <PanelHeaderAction\n              className=\"layer__duplicate\"\n              id={layerId}\n              tooltip={'tooltip.duplicateLayer'}\n              onClick={onDuplicateLayer}\n              IconComponent={actionIcons.duplicate}\n              disabled={!allowDuplicate}\n            />\n          </StyledPanelHeaderHiddenActions>\n          <PanelHeaderAction\n            className=\"layer__visibility-toggle\"\n            id={layerId}\n            tooltip={isVisible ? 'tooltip.hideLayer' : 'tooltip.showLayer'}\n            onClick={onToggleVisibility}\n            IconComponent={isVisible ? actionIcons.visible : actionIcons.hidden}\n          />\n          <PanelHeaderAction\n            className={classnames('layer__enable-config ', {\n              'is-open': isConfigActive\n            })}\n            id={layerId}\n            tooltip={'tooltip.layerSettings'}\n            onClick={onToggleEnableConfig}\n            IconComponent={actionIcons.enableConfig}\n          />\n        </HeaderActionSection>\n      </StyledLayerPanelHeader>\n    );\n  };\n\n  LayerPanelHeader.defaultProps = defaultProps;\n\n  return LayerPanelHeader;\n}\n\nexport default LayerPanelHeaderFactory;\n"]}