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

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

@@ -1,20 +1,20 @@
-import React from 'react';
-import LayerPanelFactory from './layer-panel';
-import { Datasets } from 'reducers';
-import { Layer, LayerClassesType } from 'layers';
-import * as UiStateActions from 'actions/ui-state-actions';
-import * as VisStateActions from 'actions/vis-state-actions';
-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;
+import React from 'react';
+import LayerPanelFactory from './layer-panel';
+import { Datasets } from 'reducers';
+import { Layer, LayerClassesType } from 'layers';
+import * as UiStateActions from 'actions/ui-state-actions';
+import * as VisStateActions from 'actions/vis-state-actions';
+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/components/side-panel/layer-panel/layer-list.js

@@ -0,0 +1,168 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+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 _dataUtils = require("../../../utils/data-utils");
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _reactSortableHoc = require("react-sortable-hoc");
+var _layerPanel = _interopRequireDefault(require("./layer-panel"));
+var _templateObject; // 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.
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+// 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, _dataUtils.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__*/
+    // @ts-expect-error
+    _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__*/
+      // @ts-expect-error
+      _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 = exports["default"] = LayerListFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","_dataUtils","_styledComponents","_interopRequireDefault","_classnames","_reactSortableHoc","_layerPanel","_templateObject","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","_typeof","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","SortableStyledItem","styled","div","_taggedTemplateLiteral2","props","theme","dropdownWrapperZ","panelBackgroundHover","fontFamily","fontWeight","fontSize","lineHeight","textColorHl","LayerListFactory","deps","LayerPanelFactory","LayerPanel","SortableItem","SortableElement","_ref","children","isSorting","createElement","className","classnames","sorting","WrappedSortableContainer","SortableContainer","_ref2","LayerList","layers","datasets","layerOrder","uiStateActions","visStateActions","layerClasses","_props$isSortable","isSortable","openModal","toggleModal","_useState","useState","_useState2","_slicedToArray2","setIsSorting","layerTypeOptions","useMemo","keys","map","key","layer","id","label","name","icon","layerIcon","requireData","layerActions","layerColorUIChange","layerConfigChange","layerVisualChannelConfigChange","layerTypeChange","layerVisConfigChange","layerTextLabelChange","removeLayer","duplicateLayer","panelProps","_handleSort","useCallback","_ref3","oldIndex","newIndex","reorderLayer","arrayMove","_onSortStart","_updateBeforeSortStart","_ref4","index","layerIdx","config","isConfigActive","onSortEnd","onSortStart","updateBeforeSortStart","lockAxis","helperClass","useDragHandle","hidden","concat","_extends2","idx","Fragment","isDraggable","_default","exports"],"sources":["../../../../src/components/side-panel/layer-panel/layer-list.tsx"],"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 {arrayMove} from 'utils/data-utils';\nimport styled from 'styled-components';\nimport classnames from 'classnames';\nimport {SortableContainer, SortableElement} from 'react-sortable-hoc';\nimport LayerPanelFactory from './layer-panel';\nimport {Datasets} from 'reducers';\nimport {Layer, LayerClassesType} from 'layers';\nimport * as UiStateActions from 'actions/ui-state-actions';\nimport * as VisStateActions from 'actions/vis-state-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      // @ts-expect-error\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              // @ts-expect-error\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"],"mappings":"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","ignoreList":[]}

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

@@ -1,43 +1,43 @@
-import React, { ComponentType, MouseEventHandler, ChangeEventHandler } from 'react';
-import PanelHeaderActionFactory from 'components/side-panel/panel-header-action';
-import { RGBColor } from 'reducers';
-import { BaseProps } from 'components/common/icons/base';
-type LayerLabelEditorProps = {
-    layerId: string;
-    label?: string;
-    onEdit: ChangeEventHandler;
-};
-type LayerTitleSectionProps = {
-    layerType?: string | null;
-    layerId: string;
-    label?: string;
-    onUpdateLayerLabel: ChangeEventHandler;
-};
-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;
-    isDragNDropEnabled?: boolean;
-    labelRCGColorValues?: RGBColor | null;
-    actionIcons?: Record<string, ComponentType<Partial<BaseProps>>>;
-};
-export declare const defaultProps: {
-    isDragNDropEnabled: boolean;
-    showRemoveLayer: boolean;
-};
-export declare const DragHandle: React.ComponentClass<unknown, any>;
-export declare const LayerLabelEditor: React.FC<LayerLabelEditorProps>;
-export declare function LayerTitleSectionFactory(): React.FC<LayerTitleSectionProps>;
-declare function LayerPanelHeaderFactory(LayerTitleSection: ReturnType<typeof LayerTitleSectionFactory>, PanelHeaderAction: ReturnType<typeof PanelHeaderActionFactory>): React.FC<LayerPanelHeaderProps>;
-declare namespace LayerPanelHeaderFactory {
-    var deps: (typeof LayerTitleSectionFactory | typeof PanelHeaderActionFactory)[];
-}
-export default LayerPanelHeaderFactory;
+import React, { ComponentType, MouseEventHandler, ChangeEventHandler } from 'react';
+import PanelHeaderActionFactory from 'components/side-panel/panel-header-action';
+import { RGBColor } from 'reducers';
+import { BaseProps } from 'components/common/icons/base';
+type LayerLabelEditorProps = {
+    layerId: string;
+    label?: string;
+    onEdit: ChangeEventHandler;
+};
+type LayerTitleSectionProps = {
+    layerType?: string | null;
+    layerId: string;
+    label?: string;
+    onUpdateLayerLabel: ChangeEventHandler;
+};
+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;
+    isDragNDropEnabled?: boolean;
+    labelRCGColorValues?: RGBColor | null;
+    actionIcons?: Record<string, ComponentType<Partial<BaseProps>>>;
+};
+export declare const defaultProps: {
+    isDragNDropEnabled: boolean;
+    showRemoveLayer: boolean;
+};
+export declare const DragHandle: React.ComponentClass<unknown, any>;
+export declare const LayerLabelEditor: React.FC<LayerLabelEditorProps>;
+export declare function LayerTitleSectionFactory(): React.FC<LayerTitleSectionProps>;
+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/components/side-panel/layer-panel/layer-panel-header.js

@@ -0,0 +1,194 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LayerLabelEditor = exports.DragHandle = void 0;
+exports.LayerTitleSectionFactory = LayerTitleSectionFactory;
+exports.defaultProps = exports["default"] = 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 = _interopRequireDefault(require("styled-components"));
+var _reactSortableHoc = require("react-sortable-hoc");
+var _panelHeaderAction = _interopRequireDefault(require("../panel-header-action"));
+var _icons = require("../../common/icons");
+var _styledComponents2 = require("../../common/styled-components");
+var _localization = require("../../../localization");
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5; // 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.
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+var defaultProps = exports.defaultProps = {
+  isDragNDropEnabled: true,
+  showRemoveLayer: true
+};
+var StyledLayerPanelHeader = (0, _styledComponents["default"])(_styledComponents2.StyledPanelHeader)(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  height: ", "px;\n  .layer__remove-layer {\n    opacity: 0;\n  }\n\n  .layer__drag-handle__placeholder {\n    height: 20px;\n    padding: 10px;\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.theme.panelBackgroundHover;
+});
+var HeaderLabelSection = _styledComponents["default"].div(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  display: flex;\n  color: ", ";\n"])), function (props) {
+  return props.theme.textColor;
+});
+var HeaderActionSection = _styledComponents["default"].div(_templateObject3 || (_templateObject3 = (0, _taggedTemplateLiteral2["default"])(["\n  display: flex;\n"])));
+var StyledDragHandle = _styledComponents["default"].div(_templateObject4 || (_templateObject4 = (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 = exports.DragHandle = (0, _reactSortableHoc.SortableHandle)(function (_ref) {
+  var className = _ref.className,
+    children = _ref.children;
+  return /*#__PURE__*/_react["default"].createElement(StyledDragHandle, {
+    className: className
+  }, children);
+});
+var LayerLabelEditor = exports.LayerLabelEditor = function LayerLabelEditor(_ref2) {
+  var layerId = _ref2.layerId,
+    label = _ref2.label,
+    onEdit = _ref2.onEdit;
+  return /*#__PURE__*/_react["default"].createElement(_styledComponents2.InlineInput, {
+    type: "text",
+    className: "layer__title__editor",
+    value: label,
+    onClick: function onClick(e) {
+      e.stopPropagation();
+    },
+    onChange: onEdit,
+    id: "".concat(layerId, ":input-layer-label")
+  });
+};
+function LayerTitleSectionFactory() {
+  var StyledLayerTitleSection = _styledComponents["default"].div(_templateObject5 || (_templateObject5 = (0, _taggedTemplateLiteral2["default"])(["\n    margin-left: 4px;\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(_ref3) {
+    var layerType = _ref3.layerType,
+      layerId = _ref3.layerId,
+      label = _ref3.label,
+      onUpdateLayerLabel = _ref3.onUpdateLayerLabel;
+    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
+    }), /*#__PURE__*/_react["default"].createElement("div", {
+      className: "layer__title__type"
+    }, layerType && /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+      id: "layer.type.".concat(layerType.toLowerCase())
+    }))));
+  };
+  return LayerTitleSection;
+}
+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(_ref4) {
+    var isConfigActive = _ref4.isConfigActive,
+      isDragNDropEnabled = _ref4.isDragNDropEnabled,
+      isVisible = _ref4.isVisible,
+      label = _ref4.label,
+      layerId = _ref4.layerId,
+      layerType = _ref4.layerType,
+      labelRCGColorValues = _ref4.labelRCGColorValues,
+      onToggleVisibility = _ref4.onToggleVisibility,
+      onUpdateLayerLabel = _ref4.onUpdateLayerLabel,
+      onToggleEnableConfig = _ref4.onToggleEnableConfig,
+      onDuplicateLayer = _ref4.onDuplicateLayer,
+      onRemoveLayer = _ref4.onRemoveLayer,
+      showRemoveLayer = _ref4.showRemoveLayer,
+      _ref4$actionIcons = _ref4.actionIcons,
+      actionIcons = _ref4$actionIcons === void 0 ? defaultActionIcons : _ref4$actionIcons;
+    var _useState = (0, _react.useState)(false),
+      _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+      isOpen = _useState2[0],
+      setOpen = _useState2[1];
+    var toggleLayerConfigurator = function toggleLayerConfigurator(e) {
+      setOpen(!isOpen);
+      onToggleEnableConfig(e);
+    };
+    return /*#__PURE__*/_react["default"].createElement(StyledLayerPanelHeader, {
+      className: (0, _classnames["default"])('layer-panel__header', {
+        'sort--handle': !isConfigActive
+      }),
+      active: isConfigActive,
+      labelRCGColorValues: labelRCGColorValues,
+      onClick: toggleLayerConfigurator
+    }, /*#__PURE__*/_react["default"].createElement(HeaderLabelSection, {
+      className: "layer-panel__header__content"
+    }, isDragNDropEnabled ?
+    /*#__PURE__*/
+    // @ts-expect-error
+    _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
+    })), /*#__PURE__*/_react["default"].createElement(HeaderActionSection, {
+      className: "layer-panel__header__actions"
+    }, 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__visibility-toggle",
+      id: layerId,
+      tooltip: isVisible ? 'tooltip.hideLayer' : 'tooltip.showLayer',
+      onClick: onToggleVisibility,
+      IconComponent: isVisible ? actionIcons.visible : actionIcons.hidden
+    }), /*#__PURE__*/_react["default"].createElement(PanelHeaderAction, {
+      className: "layer__duplicate",
+      id: layerId,
+      tooltip: 'tooltip.duplicateLayer',
+      onClick: onDuplicateLayer,
+      IconComponent: actionIcons.duplicate
+    }), /*#__PURE__*/_react["default"].createElement(PanelHeaderAction, {
+      className: (0, _classnames["default"])('layer__enable-config ', {
+        'is-open': isOpen
+      }),
+      id: layerId,
+      tooltip: 'tooltip.layerSettings',
+      onClick: toggleLayerConfigurator,
+      IconComponent: actionIcons.enableConfig
+    })));
+  };
+  LayerPanelHeader.defaultProps = defaultProps;
+  return LayerPanelHeader;
+}
+var _default = exports["default"] = LayerPanelHeaderFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","_classnames","_interopRequireDefault","_styledComponents","_reactSortableHoc","_panelHeaderAction","_icons","_styledComponents2","_localization","_templateObject","_templateObject2","_templateObject3","_templateObject4","_templateObject5","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","_typeof","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","defaultProps","exports","isDragNDropEnabled","showRemoveLayer","StyledLayerPanelHeader","styled","StyledPanelHeader","_taggedTemplateLiteral2","props","theme","layerPanelHeaderHeight","panelBackgroundHover","HeaderLabelSection","div","textColor","HeaderActionSection","StyledDragHandle","textColorHl","DragHandle","SortableHandle","_ref","className","children","createElement","LayerLabelEditor","_ref2","layerId","label","onEdit","InlineInput","type","value","onClick","stopPropagation","onChange","id","concat","LayerTitleSectionFactory","StyledLayerTitleSection","subtextColor","LayerTitleSection","_ref3","layerType","onUpdateLayerLabel","FormattedMessage","toLowerCase","LayerPanelHeaderFactory","deps","PanelHeaderActionFactory","defaultActionIcons","remove","Trash","visible","EyeSeen","hidden","EyeUnseen","enableConfig","ArrowDown","duplicate","Copy","PanelHeaderAction","LayerPanelHeader","_ref4","isConfigActive","isVisible","labelRCGColorValues","onToggleVisibility","onToggleEnableConfig","onDuplicateLayer","onRemoveLayer","_ref4$actionIcons","actionIcons","_useState","useState","_useState2","_slicedToArray2","isOpen","setOpen","toggleLayerConfigurator","classnames","active","VertDots","height","tooltip","tooltipType","IconComponent","_default"],"sources":["../../../../src/components/side-panel/layer-panel/layer-panel-header.tsx"],"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 from 'styled-components';\nimport {SortableHandle} from 'react-sortable-hoc';\nimport PanelHeaderActionFactory from 'components/side-panel/panel-header-action';\nimport {Copy, ArrowDown, EyeSeen, EyeUnseen, Trash, VertDots} from 'components/common/icons';\n\nimport {InlineInput, StyledPanelHeader} from 'components/common/styled-components';\nimport {FormattedMessage} from 'localization';\nimport {RGBColor} from 'reducers';\nimport {BaseProps} from 'components/common/icons/base';\n\ntype LayerLabelEditorProps = {\n  layerId: string;\n  label?: string;\n  onEdit: ChangeEventHandler;\n};\n\ntype LayerTitleSectionProps = {\n  layerType?: string | null;\n  layerId: string;\n  label?: string;\n  onUpdateLayerLabel: 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  isDragNDropEnabled?: boolean;\n  labelRCGColorValues?: RGBColor | null;\n  actionIcons?: Record<string, ComponentType<Partial<BaseProps>>>;\n};\n\nexport const defaultProps = {\n  isDragNDropEnabled: true,\n  showRemoveLayer: true\n};\n\nconst StyledLayerPanelHeader = styled(StyledPanelHeader)`\n  height: ${props => props.theme.layerPanelHeaderHeight}px;\n  .layer__remove-layer {\n    opacity: 0;\n  }\n\n  .layer__drag-handle__placeholder {\n    height: 20px;\n    padding: 10px;\n  }\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`;\n\nconst HeaderActionSection = styled.div`\n  display: flex;\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> = ({layerId, label, onEdit}) => (\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    id={`${layerId}:input-layer-label`}\n  />\n);\n\nexport function LayerTitleSectionFactory() {\n  const StyledLayerTitleSection = styled.div`\n    margin-left: 4px;\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  }) => (\n    <StyledLayerTitleSection className=\"layer__title\">\n      <div>\n        <LayerLabelEditor layerId={layerId} label={label} onEdit={onUpdateLayerLabel} />\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\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    isDragNDropEnabled,\n    isVisible,\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 [isOpen, setOpen] = useState(false);\n    const toggleLayerConfigurator = e => {\n      setOpen(!isOpen);\n      onToggleEnableConfig(e);\n    };\n\n    return (\n      <StyledLayerPanelHeader\n        className={classnames('layer-panel__header', {\n          'sort--handle': !isConfigActive\n        })}\n        active={isConfigActive}\n        labelRCGColorValues={labelRCGColorValues}\n        onClick={toggleLayerConfigurator}\n      >\n        <HeaderLabelSection className=\"layer-panel__header__content\">\n          {isDragNDropEnabled ? (\n            // @ts-expect-error\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          />\n        </HeaderLabelSection>\n        <HeaderActionSection className=\"layer-panel__header__actions\">\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__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=\"layer__duplicate\"\n            id={layerId}\n            tooltip={'tooltip.duplicateLayer'}\n            onClick={onDuplicateLayer}\n            IconComponent={actionIcons.duplicate}\n          />\n          <PanelHeaderAction\n            className={classnames('layer__enable-config ', {\n              'is-open': isOpen\n            })}\n            id={layerId}\n            tooltip={'tooltip.layerSettings'}\n            onClick={toggleLayerConfigurator}\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"],"mappings":"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","ignoreList":[]}