@kepler.gl/components 3.0.0-alpha.0

package/dist/map/map-draw-panel.js

@@ -0,0 +1,137 @@
+// 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 _react = _interopRequireWildcard(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _constants = require("@kepler.gl/constants");
+
+var _icons = require("../common/icons");
+
+var _styledComponents = require("../common/styled-components");
+
+var _toolbarItem = _interopRequireDefault(require("../common/toolbar-item"));
+
+var _mapControlTooltip = _interopRequireDefault(require("./map-control-tooltip"));
+
+var _mapControlToolbar = _interopRequireDefault(require("./map-control-toolbar"));MapDrawPanelFactory.deps = [_mapControlTooltip["default"], _mapControlToolbar["default"]];
+
+function MapDrawPanelFactory(MapControlTooltip, MapControlToolbar) {
+  var defaultActionIcons = {
+    visible: _icons.EyeSeen,
+    hidden: _icons.EyeUnseen,
+    polygon: _icons.DrawPolygon,
+    cursor: _icons.CursorClick,
+    innerPolygon: _icons.Polygon,
+    rectangle: _icons.Rectangle
+  };
+  /** @type {import('./map-draw-panel').MapDrawPanelComponent} */
+
+  var MapDrawPanel = /*#__PURE__*/_react["default"].memo(function (_ref) {
+    var _mapControls$mapDraw, _mapControls$mapDraw2;
+
+    var editor = _ref.editor,
+        mapControls = _ref.mapControls,
+        onToggleMapControl = _ref.onToggleMapControl,
+        onSetEditorMode = _ref.onSetEditorMode,
+        onToggleEditorVisibility = _ref.onToggleEditorVisibility,
+        _ref$actionIcons = _ref.actionIcons,
+        actionIcons = _ref$actionIcons === void 0 ? defaultActionIcons : _ref$actionIcons;
+    var isActive = mapControls === null || mapControls === void 0 ? void 0 : (_mapControls$mapDraw = mapControls.mapDraw) === null || _mapControls$mapDraw === void 0 ? void 0 : _mapControls$mapDraw.active;
+    var onToggleMenuPanel = (0, _react.useCallback)(function () {
+      return onToggleMapControl('mapDraw');
+    }, [onToggleMapControl]);
+
+    if (!(mapControls !== null && mapControls !== void 0 && (_mapControls$mapDraw2 = mapControls.mapDraw) !== null && _mapControls$mapDraw2 !== void 0 && _mapControls$mapDraw2.show)) {
+      return null;
+    }
+
+    return /*#__PURE__*/_react["default"].createElement("div", {
+      className: "map-draw-controls",
+      style: {
+        position: 'relative'
+      }
+    }, isActive ? /*#__PURE__*/_react["default"].createElement(MapControlToolbar, {
+      show: isActive
+    }, /*#__PURE__*/_react["default"].createElement(_toolbarItem["default"], {
+      className: "edit-feature",
+      onClick: function onClick() {
+        return onSetEditorMode(_constants.EDITOR_MODES.EDIT);
+      },
+      label: "toolbar.select",
+      icon: actionIcons.cursor,
+      active: editor.mode === _constants.EDITOR_MODES.EDIT
+    }), /*#__PURE__*/_react["default"].createElement(_toolbarItem["default"], {
+      className: "draw-feature",
+      onClick: function onClick() {
+        return onSetEditorMode(_constants.EDITOR_MODES.DRAW_POLYGON);
+      },
+      label: "toolbar.polygon",
+      icon: actionIcons.innerPolygon,
+      active: editor.mode === _constants.EDITOR_MODES.DRAW_POLYGON
+    }), /*#__PURE__*/_react["default"].createElement(_toolbarItem["default"], {
+      className: "draw-rectangle",
+      onClick: function onClick() {
+        return onSetEditorMode(_constants.EDITOR_MODES.DRAW_RECTANGLE);
+      },
+      label: "toolbar.rectangle",
+      icon: actionIcons.rectangle,
+      active: editor.mode === _constants.EDITOR_MODES.DRAW_RECTANGLE
+    }), /*#__PURE__*/_react["default"].createElement(_toolbarItem["default"], {
+      className: "toggle-features",
+      onClick: onToggleEditorVisibility,
+      label: editor.visible ? 'toolbar.hide' : 'toolbar.show',
+      icon: editor.visible ? actionIcons.visible : actionIcons.hidden
+    })) : null, /*#__PURE__*/_react["default"].createElement(MapControlTooltip, {
+      id: "map-draw",
+      message: "tooltip.DrawOnMap"
+    }, /*#__PURE__*/_react["default"].createElement(_styledComponents.MapControlButton, {
+      className: (0, _classnames["default"])('map-control-button', 'map-draw', {
+        isActive: isActive
+      }),
+      onClick: function onClick(e) {
+        e.preventDefault();
+        onToggleMenuPanel();
+      },
+      active: isActive
+    }, /*#__PURE__*/_react["default"].createElement(actionIcons.polygon, {
+      height: "22px"
+    }))));
+  });
+
+  MapDrawPanel.displayName = 'MapDrawPanel';
+  return MapDrawPanel;
+}
+
+var _default = MapDrawPanelFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/map/map-draw-panel.tsx"],"names":["MapDrawPanelFactory","deps","MapControlTooltipFactory","MapControlToolbarFactory","MapControlTooltip","MapControlToolbar","defaultActionIcons","visible","EyeSeen","hidden","EyeUnseen","polygon","DrawPolygon","cursor","CursorClick","innerPolygon","Polygon","rectangle","Rectangle","MapDrawPanel","React","memo","editor","mapControls","onToggleMapControl","onSetEditorMode","onToggleEditorVisibility","actionIcons","isActive","mapDraw","active","onToggleMenuPanel","show","position","EDITOR_MODES","EDIT","mode","DRAW_POLYGON","DRAW_RECTANGLE","e","preventDefault","displayName"],"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} from 'react';\nimport classnames from 'classnames';\n\nimport {EDITOR_MODES} from '@kepler.gl/constants';\nimport {CursorClick, DrawPolygon, EyeSeen, EyeUnseen, Polygon, Rectangle} from '../common/icons';\nimport {MapControlButton} from '../common/styled-components';\nimport ToolbarItem from '../common/toolbar-item';\nimport MapControlTooltipFactory from './map-control-tooltip';\nimport MapControlToolbarFactory from './map-control-toolbar';\nimport {Editor, MapControls} from '@kepler.gl/types';\nimport {BaseProps} from '../common/icons';\n\nMapDrawPanelFactory.deps = [MapControlTooltipFactory, MapControlToolbarFactory];\n\nexport type MapDrawPanelProps = {\n  editor: Editor;\n  mapControls: MapControls;\n  onToggleMapControl: (control: string) => void;\n  onSetEditorMode: (mode: string) => void;\n  onToggleEditorVisibility: () => void;\n  actionIcons: {[id: string]: React.ComponentType<Partial<BaseProps>>};\n};\n\nfunction MapDrawPanelFactory(MapControlTooltip, MapControlToolbar) {\n  const defaultActionIcons = {\n    visible: EyeSeen,\n    hidden: EyeUnseen,\n    polygon: DrawPolygon,\n    cursor: CursorClick,\n    innerPolygon: Polygon,\n    rectangle: Rectangle\n  };\n  /** @type {import('./map-draw-panel').MapDrawPanelComponent} */\n  const MapDrawPanel: React.FC<MapDrawPanelProps> = React.memo(\n    ({\n      editor,\n      mapControls,\n      onToggleMapControl,\n      onSetEditorMode,\n      onToggleEditorVisibility,\n      actionIcons = defaultActionIcons\n    }) => {\n      const isActive = mapControls?.mapDraw?.active;\n      const onToggleMenuPanel = useCallback(() => onToggleMapControl('mapDraw'), [\n        onToggleMapControl\n      ]);\n      if (!mapControls?.mapDraw?.show) {\n        return null;\n      }\n      return (\n        <div className=\"map-draw-controls\" style={{position: 'relative'}}>\n          {isActive ? (\n            <MapControlToolbar show={isActive}>\n              <ToolbarItem\n                className=\"edit-feature\"\n                onClick={() => onSetEditorMode(EDITOR_MODES.EDIT)}\n                label=\"toolbar.select\"\n                icon={actionIcons.cursor}\n                active={editor.mode === EDITOR_MODES.EDIT}\n              />\n              <ToolbarItem\n                className=\"draw-feature\"\n                onClick={() => onSetEditorMode(EDITOR_MODES.DRAW_POLYGON)}\n                label=\"toolbar.polygon\"\n                icon={actionIcons.innerPolygon}\n                active={editor.mode === EDITOR_MODES.DRAW_POLYGON}\n              />\n              <ToolbarItem\n                className=\"draw-rectangle\"\n                onClick={() => onSetEditorMode(EDITOR_MODES.DRAW_RECTANGLE)}\n                label=\"toolbar.rectangle\"\n                icon={actionIcons.rectangle}\n                active={editor.mode === EDITOR_MODES.DRAW_RECTANGLE}\n              />\n              <ToolbarItem\n                className=\"toggle-features\"\n                onClick={onToggleEditorVisibility}\n                label={editor.visible ? 'toolbar.hide' : 'toolbar.show'}\n                icon={editor.visible ? actionIcons.visible : actionIcons.hidden}\n              />\n            </MapControlToolbar>\n          ) : null}\n          <MapControlTooltip id=\"map-draw\" message=\"tooltip.DrawOnMap\">\n            <MapControlButton\n              className={classnames('map-control-button', 'map-draw', {isActive})}\n              onClick={e => {\n                e.preventDefault();\n                onToggleMenuPanel();\n              }}\n              active={isActive}\n            >\n              <actionIcons.polygon height=\"22px\" />\n            </MapControlButton>\n          </MapControlTooltip>\n        </div>\n      );\n    }\n  );\n\n  MapDrawPanel.displayName = 'MapDrawPanel';\n  return MapDrawPanel;\n}\n\nexport default MapDrawPanelFactory;\n"]}

package/dist/map/map-legend-panel.d.ts

@@ -0,0 +1,24 @@
+import React, { ComponentType } from 'react';
+import MapControlTooltipFactory from './map-control-tooltip';
+import MapControlPanelFactory from './map-control-panel';
+import MapLegendFactory from './map-legend';
+import { MapControls } from '@kepler.gl/types';
+import { Layer } from '@kepler.gl/layers';
+interface MapLegendPanelIcons {
+    legend: ComponentType<any>;
+}
+export declare type MapLegendPanelProps = {
+    layers: ReadonlyArray<Layer>;
+    scale: number;
+    onToggleMapControl: (control: string) => void;
+    isExport: boolean;
+    logoComponent: Element;
+    actionIcons: MapLegendPanelIcons;
+    mapControls: MapControls;
+    mapHeight?: number;
+};
+declare function MapLegendPanelFactory(MapControlTooltip: any, MapControlPanel: any, MapLegend: any): React.FC<MapLegendPanelProps>;
+declare namespace MapLegendPanelFactory {
+    var deps: (typeof MapControlTooltipFactory | typeof MapControlPanelFactory | typeof MapLegendFactory)[];
+}
+export default MapLegendPanelFactory;

package/dist/map/map-legend-panel.js

@@ -0,0 +1,181 @@
+// 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 _icons = require("../common/icons");
+
+var _styledComponents2 = require("../common/styled-components");
+
+var _mapControlTooltip = _interopRequireDefault(require("./map-control-tooltip"));
+
+var _mapControlPanel = _interopRequireDefault(require("./map-control-panel"));
+
+var _mapLegend = _interopRequireDefault(require("./map-legend"));
+
+var _lazyTippy = _interopRequireDefault(require("./lazy-tippy"));
+
+var _reactDom = require("react-dom");
+
+var _constants = require("@kepler.gl/constants");
+
+var _styles = require("@kepler.gl/styles");
+
+var _templateObject, _templateObject2;
+
+MapLegendPanelFactory.deps = [_mapControlTooltip["default"], _mapControlPanel["default"], _mapLegend["default"]];
+
+var PinToBottom = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  position: absolute;\n  bottom: ", "px;\n  right: ", "px;\n  ", ";\n"])), _constants.DIMENSIONS.mapControl.mapLegend.pinned.bottom, _constants.DIMENSIONS.mapControl.mapLegend.pinned.right, _styles.media.portable(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n    bottom: 0px;\n    right: 0px;\n    min-width: ", "px;\n    .map-control-panel {\n      min-height: 215px;\n      margin-bottom: 0px;\n    };\n  "])), _constants.DIMENSIONS.mapControl.width + _constants.DIMENSIONS.mapControl.mapLegend.pinned.right));
+
+function MapLegendPanelFactory(MapControlTooltip, MapControlPanel, MapLegend) {
+  var defaultActionIcons = {
+    legend: _icons.Legend
+  };
+  /** @type {import('./map-legend-panel').MapLegendPanelComponent} */
+
+  var MapLegendPanel = function MapLegendPanel(_ref) {
+    var layers = _ref.layers,
+        mapControls = _ref.mapControls,
+        scale = _ref.scale,
+        onToggleMapControl = _ref.onToggleMapControl,
+        isExport = _ref.isExport,
+        logoComponent = _ref.logoComponent,
+        _ref$actionIcons = _ref.actionIcons,
+        actionIcons = _ref$actionIcons === void 0 ? defaultActionIcons : _ref$actionIcons,
+        mapHeight = _ref.mapHeight;
+    var mapLegend = (mapControls === null || mapControls === void 0 ? void 0 : mapControls.mapLegend) || {};
+
+    var _ref2 = mapLegend || {},
+        isPinned = _ref2.active;
+
+    var onClick = function onClick() {
+      var _mapControls$mapDraw;
+
+      if (mapControls !== null && mapControls !== void 0 && (_mapControls$mapDraw = mapControls.mapDraw) !== null && _mapControls$mapDraw !== void 0 && _mapControls$mapDraw.active) {
+        onToggleMapControl('mapDraw');
+      }
+    };
+
+    var _useState = (0, _react.useState)(null),
+        _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+        tippyInstance = _useState2[0],
+        setTippyInstance = _useState2[1];
+
+    var onCloseClick = function onCloseClick(e) {
+      e.preventDefault();
+      onToggleMapControl('mapLegend');
+    };
+
+    var onPinClick = function onPinClick(e) {
+      e.preventDefault();
+
+      if (tippyInstance) {
+        // @ts-ignore
+        tippyInstance.hide();
+      }
+
+      onToggleMapControl('mapLegend');
+    };
+
+    if (!mapLegend.show) {
+      return null;
+    }
+
+    var mapControlPanel = /*#__PURE__*/_react["default"].createElement(MapControlPanel, (0, _extends2["default"])({
+      scale: scale,
+      header: 'header.layerLegend',
+      isPinned: true
+    }, isPinned ? {
+      onClick: onCloseClick,
+      pinnable: false,
+      disableClose: false
+    } : {
+      onPinClick: onPinClick,
+      pinnable: true,
+      disableClose: true
+    }, {
+      isExport: isExport,
+      logoComponent: logoComponent
+    }), /*#__PURE__*/_react["default"].createElement(MapLegend, {
+      layers: layers,
+      mapHeight: mapHeight
+    }));
+
+    if (isPinned) {
+      // Pinned panel is not supported in export mode
+      if (isExport) {
+        return mapControlPanel;
+      }
+
+      var pinnedPanel = /*#__PURE__*/_react["default"].createElement(PinToBottom, null, mapControlPanel);
+
+      return /*#__PURE__*/(0, _reactDom.createPortal)(pinnedPanel, document.body);
+    }
+
+    return (
+      /*#__PURE__*/
+      // The outer div is to prevent an accessibility warning from Tippy
+      _react["default"].createElement("div", null, /*#__PURE__*/_react["default"].createElement(_lazyTippy["default"], {
+        interactive: true,
+        trigger: "click",
+        placement: "left-start",
+        onCreate: setTippyInstance,
+        render: function render(attrs) {
+          return /*#__PURE__*/_react["default"].createElement("div", attrs, mapControlPanel);
+        },
+        appendTo: "parent"
+      }, /*#__PURE__*/_react["default"].createElement("div", null, /*#__PURE__*/_react["default"].createElement(MapControlTooltip, {
+        id: "show-legend",
+        message: "tooltip.showLegend"
+      }, /*#__PURE__*/_react["default"].createElement(_styledComponents2.MapControlButton, {
+        className: "map-control-button show-legend",
+        onClick: onClick
+      }, /*#__PURE__*/_react["default"].createElement(actionIcons.legend, {
+        height: "22px"
+      }))))))
+    );
+  };
+
+  MapLegendPanel.displayName = 'MapLegendPanel';
+  return MapLegendPanel;
+}
+
+var _default = MapLegendPanelFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/map/map-legend-panel.tsx"],"names":["MapLegendPanelFactory","deps","MapControlTooltipFactory","MapControlPanelFactory","MapLegendFactory","PinToBottom","styled","div","DIMENSIONS","mapControl","mapLegend","pinned","bottom","right","media","portable","width","MapControlTooltip","MapControlPanel","MapLegend","defaultActionIcons","legend","Legend","MapLegendPanel","layers","mapControls","scale","onToggleMapControl","isExport","logoComponent","actionIcons","mapHeight","isPinned","active","onClick","mapDraw","tippyInstance","setTippyInstance","onCloseClick","e","preventDefault","onPinClick","hide","show","mapControlPanel","pinnable","disableClose","pinnedPanel","document","body","attrs","displayName"],"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, {ComponentType, useState} from 'react';\nimport styled from 'styled-components';\n\nimport {Legend} from '../common/icons';\nimport {MapControlButton} from '../common/styled-components';\nimport MapControlTooltipFactory from './map-control-tooltip';\nimport MapControlPanelFactory from './map-control-panel';\nimport MapLegendFactory from './map-legend';\nimport LazyTippy from './lazy-tippy';\nimport {createPortal} from 'react-dom';\nimport {DIMENSIONS} from '@kepler.gl/constants';\nimport {MapControl, MapControls} from '@kepler.gl/types';\nimport {Layer} from '@kepler.gl/layers';\nimport {media} from '@kepler.gl/styles';\n\nMapLegendPanelFactory.deps = [MapControlTooltipFactory, MapControlPanelFactory, MapLegendFactory];\n\nconst PinToBottom = styled.div`\n  position: absolute;\n  bottom: ${DIMENSIONS.mapControl.mapLegend.pinned.bottom}px;\n  right: ${DIMENSIONS.mapControl.mapLegend.pinned.right}px;\n  ${media.portable`\n    bottom: 0px;\n    right: 0px;\n    min-width: ${DIMENSIONS.mapControl.width + DIMENSIONS.mapControl.mapLegend.pinned.right}px;\n    .map-control-panel {\n      min-height: 215px;\n      margin-bottom: 0px;\n    };\n  `};\n`;\n\ninterface MapLegendPanelIcons {\n  legend: ComponentType<any>;\n}\n\nexport type MapLegendPanelProps = {\n  layers: ReadonlyArray<Layer>;\n  scale: number;\n  onToggleMapControl: (control: string) => void;\n  isExport: boolean;\n  logoComponent: Element;\n  actionIcons: MapLegendPanelIcons;\n  mapControls: MapControls;\n  mapHeight?: number;\n};\n\nfunction MapLegendPanelFactory(MapControlTooltip, MapControlPanel, MapLegend) {\n  const defaultActionIcons = {\n    legend: Legend\n  };\n\n  /** @type {import('./map-legend-panel').MapLegendPanelComponent} */\n  const MapLegendPanel: React.FC<MapLegendPanelProps> = ({\n    layers,\n    mapControls,\n    scale,\n    onToggleMapControl,\n    isExport,\n    logoComponent,\n    actionIcons = defaultActionIcons,\n    mapHeight\n  }) => {\n    const mapLegend = mapControls?.mapLegend || ({} as MapControl);\n    const {active: isPinned} = mapLegend || {};\n\n    const onClick = () => {\n      if (mapControls?.mapDraw?.active) {\n        onToggleMapControl('mapDraw');\n      }\n    };\n    const [tippyInstance, setTippyInstance] = useState(null);\n    const onCloseClick = e => {\n      e.preventDefault();\n      onToggleMapControl('mapLegend');\n    };\n    const onPinClick = e => {\n      e.preventDefault();\n      if (tippyInstance) {\n        // @ts-ignore\n        tippyInstance.hide();\n      }\n      onToggleMapControl('mapLegend');\n    };\n\n    if (!mapLegend.show) {\n      return null;\n    }\n    const mapControlPanel = (\n      <MapControlPanel\n        scale={scale}\n        header={'header.layerLegend'}\n        isPinned={true}\n        {...(isPinned\n          ? {\n              onClick: onCloseClick,\n              pinnable: false,\n              disableClose: false\n            }\n          : {\n              onPinClick,\n              pinnable: true,\n              disableClose: true\n            })}\n        isExport={isExport}\n        logoComponent={logoComponent}\n      >\n        <MapLegend layers={layers} mapHeight={mapHeight} />\n      </MapControlPanel>\n    );\n\n    if (isPinned) {\n      // Pinned panel is not supported in export mode\n      if (isExport) {\n        return mapControlPanel;\n      }\n      const pinnedPanel = <PinToBottom>{mapControlPanel}</PinToBottom>;\n      return createPortal(pinnedPanel, document.body);\n    }\n\n    return (\n      // The outer div is to prevent an accessibility warning from Tippy\n      <div>\n        {/* \n  // @ts-ignore */}\n        <LazyTippy\n          interactive={true}\n          trigger=\"click\"\n          placement=\"left-start\"\n          onCreate={setTippyInstance}\n          render={attrs => <div {...attrs}>{mapControlPanel}</div>}\n          appendTo=\"parent\"\n        >\n          <div>\n            <MapControlTooltip id=\"show-legend\" message=\"tooltip.showLegend\">\n              <MapControlButton className=\"map-control-button show-legend\" onClick={onClick}>\n                <actionIcons.legend height=\"22px\" />\n              </MapControlButton>\n            </MapControlTooltip>\n          </div>\n        </LazyTippy>\n      </div>\n    );\n  };\n\n  MapLegendPanel.displayName = 'MapLegendPanel';\n  return MapLegendPanel;\n}\n\nexport default MapLegendPanelFactory;\n"]}

package/dist/map/map-legend.d.ts

@@ -0,0 +1,55 @@
+import React from 'react';
+import { Layer, LayerBaseConfig, VisualChannel, VisualChannelDescription } from '@kepler.gl/layers';
+interface StyledMapControlLegendProps {
+    width?: number;
+    last?: boolean;
+}
+export declare const StyledMapControlLegend: import("styled-components").StyledComponent<"div", any, StyledMapControlLegendProps, never>;
+export declare const VisualChannelMetric: ({ name }: {
+    name: any;
+}) => JSX.Element;
+export declare type LayerSizeLegendProps = {
+    label: string;
+    name: string | undefined;
+};
+/** @type {typeof import('./map-legend').LayerSizeLegend} */
+export declare const LayerSizeLegend: React.FC<LayerSizeLegendProps>;
+export declare type SingleColorLegendProps = {
+    width: number;
+    color: string;
+};
+/** @type {typeof import('./map-legend').SingleColorLegend} */
+export declare const SingleColorLegend: React.FC<SingleColorLegendProps>;
+export declare type LayerColorLegendProps = {
+    description: VisualChannelDescription;
+    config: LayerBaseConfig;
+    width: number;
+    colorChannel: VisualChannel;
+};
+/** @type {typeof import('./map-legend').LayerColorLegend} */
+export declare const LayerColorLegend: React.FC<LayerColorLegendProps>;
+export declare type LayerLegendHeaderProps = {
+    layer: Layer;
+    options?: {
+        showLayerName?: boolean;
+    };
+};
+export declare function LayerLegendHeaderFactory(): React.FC<LayerLegendHeaderProps>;
+export declare type LayerLegendContentProps = {
+    layer: Layer;
+    containerW: number;
+};
+export declare function LayerLegendContentFactory(): React.FC<LayerLegendContentProps>;
+export declare type MapLegendProps = {
+    layers?: ReadonlyArray<Layer>;
+    width?: number;
+    mapHeight?: number;
+    options?: {
+        showLayerName?: boolean;
+    };
+};
+declare function MapLegendFactory(LayerLegendHeader: any, LayerLegendContent: any): React.FC<MapLegendProps>;
+declare namespace MapLegendFactory {
+    var deps: (typeof LayerLegendHeaderFactory | typeof LayerLegendContentFactory)[];
+}
+export default MapLegendFactory;