@kepler.gl/components 3.0.0-alpha.0

package/dist/side-panel/layer-panel/layer-type-selector.js

@@ -0,0 +1,91 @@
+// 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 _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _styledComponents = _interopRequireWildcard(require("styled-components"));
+
+var _layerTypeDropdownList = _interopRequireDefault(require("./layer-type-dropdown-list"));
+
+var _layerTypeListItem = _interopRequireDefault(require("./layer-type-list-item"));
+
+var _itemSelector = _interopRequireDefault(require("../../common/item-selector/item-selector"));
+
+var _styledComponents2 = require("../../common/styled-components");
+
+var _templateObject;
+
+var StyledLayerTypeSelector = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  .item-selector .item-selector__dropdown {\n    padding: 4px 10px 4px 10px;\n  }\n"])));
+
+LayerTypeSelectorFactory.deps = [_layerTypeListItem["default"], _layerTypeDropdownList["default"]];
+
+var getDisplayOption = function getDisplayOption(op) {
+  return op.label;
+};
+
+var getOptionValue = function getOptionValue(op) {
+  return op.id;
+};
+
+function LayerTypeSelectorFactory(LayerTypeListItem, LayerTypeDropdownList) {
+  var LayerTypeSelector = function LayerTypeSelector(_ref) {
+    var selected = _ref.selected,
+        options = _ref.options,
+        onSelect = _ref.onSelect;
+    var selectedItems = (0, _react.useMemo)(function () {
+      return options.find(function (op) {
+        return op.id === selected;
+      });
+    }, [options, selected]);
+    return /*#__PURE__*/_react["default"].createElement(_styledComponents2.SidePanelSection, null, /*#__PURE__*/_react["default"].createElement(StyledLayerTypeSelector, {
+      className: "layer-config__type"
+    }, /*#__PURE__*/_react["default"].createElement(_itemSelector["default"], {
+      selectedItems: selectedItems,
+      options: options,
+      multiSelect: false,
+      placeholder: "placeholder.selectType",
+      onChange: onSelect,
+      getOptionValue: getOptionValue,
+      filterOption: "label",
+      displayOption: getDisplayOption,
+      DropDownLineItemRenderComponent: LayerTypeListItem,
+      DropDownRenderComponent: LayerTypeDropdownList
+    })));
+  };
+
+  return (0, _styledComponents.withTheme)(LayerTypeSelector);
+}
+
+var _default = LayerTypeSelectorFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,36 @@
+import React from 'react';
+import { LayerPanelListView } from '@kepler.gl/types';
+declare type ToggleOptionProps = {
+    isActive: boolean;
+    onClick: () => void;
+    option: typeof TOGGLE_OPTIONS[0];
+};
+declare type PanelViewListToggleProps = {
+    layerPanelListViewMode: LayerPanelListView;
+    toggleLayerPanelListView: (view: string) => void;
+};
+export declare const StyledToggleOption: import("styled-components").StyledComponent<"div", any, {
+    className: "layer-panel-toggle-option";
+} & {
+    active: boolean;
+}, "className">;
+declare function ToggleOptionFactory(): React.FC<ToggleOptionProps>;
+declare const TOGGLE_OPTIONS: {
+    id: string;
+    iconComponent: {
+        (props: Partial<import("../../common/icons").BaseProps>): JSX.Element;
+        defaultProps: {
+            height: string;
+            fill: string;
+            viewBox: string;
+            predefinedClassName: string;
+        };
+    };
+    value: string;
+    label: string;
+}[];
+declare function PanelViewListToggleFactory(ToggleOption: ReturnType<typeof ToggleOptionFactory>): React.FC<PanelViewListToggleProps>;
+declare namespace PanelViewListToggleFactory {
+    var deps: (typeof ToggleOptionFactory)[];
+}
+export default PanelViewListToggleFactory;

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

@@ -0,0 +1,143 @@
+// 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"] = exports.StyledToggleOption = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _orderByList = _interopRequireDefault(require("../../common/icons/order-by-list"));
+
+var _orderByDataset = _interopRequireDefault(require("../../common/icons/order-by-dataset"));
+
+var _styledComponents2 = require("../../common/styled-components");
+
+var _localization = require("@kepler.gl/localization");
+
+var _templateObject, _templateObject2, _templateObject3;
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var PanelViewListToggleContainer = _styledComponents["default"].div.attrs({
+  className: 'panel-view-list-toggle'
+})(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])([""])));
+
+var PanelViewListToggleWrapper = _styledComponents["default"].div.attrs({
+  className: 'panel-view-list-toggle-inner'
+})(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  display: flex;\n  justify-content: flex-end;\n  align-content: center;\n  gap: 10px;\n"])));
+
+var StyledToggleOption = _styledComponents["default"].div.attrs({
+  className: 'layer-panel-toggle-option'
+})(_templateObject3 || (_templateObject3 = (0, _taggedTemplateLiteral2["default"])(["\n  color: ", ";\n  :hover {\n    cursor: pointer;\n    color: ", ";\n  }\n"])), function (props) {
+  return props.active ? props.theme.layerPanelToggleOptionColorActive : props.theme.layerPanelToggleOptionColor;
+}, function (props) {
+  return props.theme.layerPanelToggleOptionColorActive;
+});
+
+exports.StyledToggleOption = StyledToggleOption;
+
+function ToggleOptionFactory() {
+  var ToggleOption = function ToggleOption(_ref) {
+    var isActive = _ref.isActive,
+        onClick = _ref.onClick,
+        option = _ref.option;
+    return /*#__PURE__*/_react["default"].createElement(StyledToggleOption, {
+      "data-tip": true,
+      "data-for": "".concat(option.id, "-toggle-option"),
+      active: isActive,
+      onClick: onClick
+    }, /*#__PURE__*/_react["default"].createElement(option.iconComponent, {
+      height: "20px"
+    }), /*#__PURE__*/_react["default"].createElement(_styledComponents2.Tooltip, {
+      id: "".concat(option.id, "-toggle-option"),
+      effect: "solid",
+      delayShow: 500,
+      place: "bottom"
+    }, /*#__PURE__*/_react["default"].createElement("span", null, /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+      id: option.label
+    }))));
+  };
+
+  return ToggleOption;
+}
+
+var TOGGLE_OPTIONS = [{
+  id: 'list',
+  iconComponent: _orderByList["default"],
+  value: 'list',
+  label: 'List'
+}, {
+  id: 'sort-by-dataset',
+  iconComponent: _orderByDataset["default"],
+  value: 'sortByDataset',
+  label: 'Sort by dataset'
+}];
+PanelViewListToggleFactory.deps = [ToggleOptionFactory];
+
+function PanelViewListToggleFactory(ToggleOption) {
+  var PanelViewListToggle = function PanelViewListToggle(props) {
+    var layerPanelListViewMode = props.layerPanelListViewMode,
+        toggleLayerPanelListView = props.toggleLayerPanelListView;
+
+    var toggleListView = function toggleListView(listView) {
+      return toggleLayerPanelListView(listView);
+    };
+
+    var options = (0, _react.useMemo)(function () {
+      return TOGGLE_OPTIONS.map(function (opt) {
+        return _objectSpread(_objectSpread({}, opt), {}, {
+          isActive: layerPanelListViewMode === opt.value
+        });
+      });
+    }, [layerPanelListViewMode]);
+    return /*#__PURE__*/_react["default"].createElement(PanelViewListToggleContainer, null, /*#__PURE__*/_react["default"].createElement(PanelViewListToggleWrapper, null, options.map(function (opt) {
+      return /*#__PURE__*/_react["default"].createElement(ToggleOption, {
+        key: opt.id,
+        onClick: function onClick() {
+          return toggleListView(opt.value);
+        },
+        option: opt,
+        isActive: opt.isActive
+      });
+    })));
+  };
+
+  return PanelViewListToggle;
+}
+
+var _default = PanelViewListToggleFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/side-panel/layer-panel/panel-view-list-toggle.tsx"],"names":["PanelViewListToggleContainer","styled","div","attrs","className","PanelViewListToggleWrapper","StyledToggleOption","props","active","theme","layerPanelToggleOptionColorActive","layerPanelToggleOptionColor","ToggleOptionFactory","ToggleOption","isActive","onClick","option","id","label","TOGGLE_OPTIONS","iconComponent","OrderByList","value","OrderByDataset","PanelViewListToggleFactory","deps","PanelViewListToggle","layerPanelListViewMode","toggleLayerPanelListView","toggleListView","listView","options","map","opt"],"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, {useMemo} from 'react';\nimport styled from 'styled-components';\nimport OrderByList from '../../common/icons/order-by-list';\nimport OrderByDataset from '../../common/icons/order-by-dataset';\nimport {Tooltip} from '../../common/styled-components';\nimport {FormattedMessage} from '@kepler.gl/localization';\nimport {LayerPanelListView} from '@kepler.gl/types';\n\ntype ToggleOptionProps = {\n  isActive: boolean;\n  onClick: () => void;\n  option: typeof TOGGLE_OPTIONS[0];\n};\n\ntype PanelViewListToggleProps = {\n  layerPanelListViewMode: LayerPanelListView;\n  toggleLayerPanelListView: (view: string) => void;\n};\n\nconst PanelViewListToggleContainer = styled.div.attrs({\n  className: 'panel-view-list-toggle'\n})``;\n\nconst PanelViewListToggleWrapper = styled.div.attrs({\n  className: 'panel-view-list-toggle-inner'\n})`\n  display: flex;\n  justify-content: flex-end;\n  align-content: center;\n  gap: 10px;\n`;\n\nexport const StyledToggleOption = styled.div.attrs({\n  className: 'layer-panel-toggle-option'\n})<{active: boolean}>`\n  color: ${props =>\n    props.active\n      ? props.theme.layerPanelToggleOptionColorActive\n      : props.theme.layerPanelToggleOptionColor};\n  :hover {\n    cursor: pointer;\n    color: ${props => props.theme.layerPanelToggleOptionColorActive};\n  }\n`;\n\nfunction ToggleOptionFactory() {\n  const ToggleOption: React.FC<ToggleOptionProps> = ({isActive, onClick, option}) => (\n    <StyledToggleOption\n      data-tip\n      data-for={`${option.id}-toggle-option`}\n      active={isActive}\n      onClick={onClick}\n    >\n      <option.iconComponent height=\"20px\" />\n      <Tooltip id={`${option.id}-toggle-option`} effect=\"solid\" delayShow={500} place=\"bottom\">\n        <span>\n          <FormattedMessage id={option.label} />\n        </span>\n      </Tooltip>\n    </StyledToggleOption>\n  );\n\n  return ToggleOption;\n}\n\nconst TOGGLE_OPTIONS = [\n  {\n    id: 'list',\n    iconComponent: OrderByList,\n    value: 'list',\n    label: 'List'\n  },\n  {\n    id: 'sort-by-dataset',\n    iconComponent: OrderByDataset,\n    value: 'sortByDataset',\n    label: 'Sort by dataset'\n  }\n];\n\nPanelViewListToggleFactory.deps = [ToggleOptionFactory];\n\nfunction PanelViewListToggleFactory(ToggleOption: ReturnType<typeof ToggleOptionFactory>) {\n  const PanelViewListToggle: React.FC<PanelViewListToggleProps> = props => {\n    const {layerPanelListViewMode, toggleLayerPanelListView} = props;\n\n    const toggleListView = (listView: string) => toggleLayerPanelListView(listView);\n    const options = useMemo(\n      () => TOGGLE_OPTIONS.map(opt => ({...opt, isActive: layerPanelListViewMode === opt.value})),\n      [layerPanelListViewMode]\n    );\n\n    return (\n      <PanelViewListToggleContainer>\n        <PanelViewListToggleWrapper>\n          {options.map(opt => (\n            <ToggleOption\n              key={opt.id}\n              onClick={() => toggleListView(opt.value)}\n              option={opt}\n              isActive={opt.isActive}\n            />\n          ))}\n        </PanelViewListToggleWrapper>\n      </PanelViewListToggleContainer>\n    );\n  };\n\n  return PanelViewListToggle;\n}\n\nexport default PanelViewListToggleFactory;\n"]}

package/dist/side-panel/layer-panel/single-color-palette.d.ts

@@ -0,0 +1,9 @@
+import React, { MouseEvent } from 'react';
+import { ColorRange } from '@kepler.gl/constants';
+import { RGBColor } from '@kepler.gl/types';
+declare type SingleColorPaletteProps = {
+    onSelectColor: (color: RGBColor | ColorRange, e: MouseEvent) => void;
+    selectedColor: string;
+};
+declare const SingleColorPalette: React.FC<SingleColorPaletteProps>;
+export default SingleColorPalette;

package/dist/side-panel/layer-panel/single-color-palette.js

@@ -0,0 +1,81 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _d3Array = require("d3-array");
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _utils = require("@kepler.gl/utils");
+
+var _constants = require("@kepler.gl/constants");
+
+var _templateObject, _templateObject2, _templateObject3;
+
+var PALETTE_HEIGHT = '8px';
+var ROWS = 22;
+
+var StyledColorPalette = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  display: flex;\n  flex-direction: row;\n  justify-content: space-between;\n  padding: 12px;\n\n  :hover {\n    cursor: pointer;\n  }\n"])));
+
+var StyledColorColumn = _styledComponents["default"].div(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  display: flex;\n  flex-grow: 1;\n  flex-direction: column;\n  justify-content: space-between;\n"])));
+
+var StyledColorBlock = _styledComponents["default"].div(_templateObject3 || (_templateObject3 = (0, _taggedTemplateLiteral2["default"])(["\n  flex-grow: 1;\n  height: ", ";\n  border-width: 1px;\n  border-style: solid;\n"])), PALETTE_HEIGHT);
+
+var SingleColorPalette = function SingleColorPalette(_ref) {
+  var selectedColor = _ref.selectedColor,
+      onSelectColor = _ref.onSelectColor;
+  return /*#__PURE__*/_react["default"].createElement(StyledColorPalette, {
+    className: "single-color-palette"
+  }, _constants.Themes.map(function (theme, col) {
+    return /*#__PURE__*/_react["default"].createElement(StyledColorColumn, {
+      key: theme,
+      className: "single-color-palette__column"
+    }, (0, _d3Array.range)(1, ROWS + 1, 1).map(function (key, i) {
+      return /*#__PURE__*/_react["default"].createElement(StyledColorBlock, {
+        className: "single-color-palette__block",
+        style: {
+          backgroundColor: _constants.ColorsByTheme[theme][key],
+          borderColor: selectedColor === _constants.ColorsByTheme[theme][key].toUpperCase() ? 'white' : _constants.ColorsByTheme[theme][key]
+        },
+        key: "".concat(theme, "_").concat(key),
+        selected: selectedColor === _constants.ColorsByTheme[theme][key].toUpperCase(),
+        onClick: function onClick(e) {
+          return onSelectColor((0, _utils.hexToRgb)(_constants.ColorsByTheme[theme][key]), e);
+        }
+      });
+    }));
+  }));
+};
+
+var _default = SingleColorPalette;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/side-panel/layer-panel/text-label-panel.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import LayerConfigGroupFactory from './layer-config-group';
+import RangeSliderFactory from '../../common/range-slider';
+import FieldSelectorFactory from '../../common/field-selector';
+import { LayerTextLabel, Field } from '@kepler.gl/types';
+declare type TextLabelPanelProps = {
+    fields: Field[];
+    textLabel: LayerTextLabel[];
+    updateLayerTextLabel: (idx: number | 'all', prop: string, value: any) => void;
+};
+declare function TextLabelPanelFactory(RangeSlider: ReturnType<typeof RangeSliderFactory>, LayerConfigGroup: ReturnType<typeof LayerConfigGroupFactory>, FieldSelector: ReturnType<typeof FieldSelectorFactory>): React.ComponentType<TextLabelPanelProps>;
+declare namespace TextLabelPanelFactory {
+    var deps: (typeof RangeSliderFactory | typeof FieldSelectorFactory | typeof LayerConfigGroupFactory)[];
+}
+export default TextLabelPanelFactory;

package/dist/side-panel/layer-panel/text-label-panel.js

@@ -0,0 +1,171 @@
+// 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 _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _localization = require("@kepler.gl/localization");
+
+var _styledComponents = require("../../common/styled-components");
+
+var _icons = require("../../common/icons");
+
+var _colorSelector = _interopRequireDefault(require("./color-selector"));
+
+var _itemSelector = _interopRequireDefault(require("../../common/item-selector/item-selector"));
+
+var _layerConfigGroup = _interopRequireWildcard(require("./layer-config-group"));
+
+var _rangeSlider = _interopRequireDefault(require("../../common/range-slider"));
+
+var _fieldSelector = _interopRequireDefault(require("../../common/field-selector"));
+
+var _constants = require("@kepler.gl/constants");
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+TextLabelPanelFactory.deps = [_rangeSlider["default"], _layerConfigGroup["default"], _fieldSelector["default"]];
+
+function TextLabelPanelFactory(RangeSlider, LayerConfigGroup, FieldSelector) {
+  var TextLabelPanel = /*#__PURE__*/function (_Component) {
+    (0, _inherits2["default"])(TextLabelPanel, _Component);
+
+    var _super = _createSuper(TextLabelPanel);
+
+    function TextLabelPanel() {
+      (0, _classCallCheck2["default"])(this, TextLabelPanel);
+      return _super.apply(this, arguments);
+    }
+
+    (0, _createClass2["default"])(TextLabelPanel, [{
+      key: "render",
+      value: function render() {
+        var _this$props = this.props,
+            updateLayerTextLabel = _this$props.updateLayerTextLabel,
+            textLabel = _this$props.textLabel,
+            fields = _this$props.fields;
+        var currentFields = textLabel.map(function (tl) {
+          return tl.field && tl.field.name;
+        }).filter(function (d) {
+          return Boolean(d);
+        });
+        return /*#__PURE__*/_react["default"].createElement(LayerConfigGroup, {
+          label: 'panel.text.label',
+          collapsible: true
+        }, /*#__PURE__*/_react["default"].createElement(_layerConfigGroup.ConfigGroupCollapsibleHeader, null, /*#__PURE__*/_react["default"].createElement(FieldSelector, {
+          fields: fields,
+          value: currentFields,
+          onSelect: function onSelect(selected) {
+            return updateLayerTextLabel('all', 'fields', selected);
+          },
+          multiSelect: true
+        })), /*#__PURE__*/_react["default"].createElement(_layerConfigGroup.ConfigGroupCollapsibleContent, null, textLabel.map(function (tl, idx) {
+          return /*#__PURE__*/_react["default"].createElement("div", {
+            key: tl.field ? tl.field.name : "null-".concat(idx)
+          }, /*#__PURE__*/_react["default"].createElement(_styledComponents.PanelLabel, null, /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+            id: 'panel.text.labelWithId',
+            values: {
+              labelId: idx + 1
+            }
+          })), /*#__PURE__*/_react["default"].createElement(_styledComponents.SidePanelSection, null, /*#__PURE__*/_react["default"].createElement(FieldSelector, {
+            fields: fields,
+            value: tl.field && tl.field.name || 'placeholder.selectField',
+            placeholder: 'placeholder.empty',
+            onSelect: function onSelect(v) {
+              return updateLayerTextLabel(idx, 'field', v);
+            },
+            erasable: true
+          })), /*#__PURE__*/_react["default"].createElement(_styledComponents.SidePanelSection, null, /*#__PURE__*/_react["default"].createElement(_styledComponents.PanelLabel, null, /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+            id: "panel.text.fontSize"
+          })), /*#__PURE__*/_react["default"].createElement(RangeSlider, (0, _extends2["default"])({}, _constants.LAYER_TEXT_CONFIGS.fontSize, {
+            value1: tl.size,
+            isRanged: false,
+            onChange: function onChange(v) {
+              return updateLayerTextLabel(idx, 'size', v[1]);
+            }
+          }))), /*#__PURE__*/_react["default"].createElement(_styledComponents.SidePanelSection, null, /*#__PURE__*/_react["default"].createElement(_styledComponents.PanelLabel, null, /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+            id: "panel.text.fontColor"
+          })), /*#__PURE__*/_react["default"].createElement(_colorSelector["default"], {
+            colorSets: [{
+              selectedColor: tl.color,
+              setColor: function setColor(v) {
+                return updateLayerTextLabel(idx, 'color', v);
+              }
+            }]
+          })), /*#__PURE__*/_react["default"].createElement(_styledComponents.SidePanelSection, null, /*#__PURE__*/_react["default"].createElement(_styledComponents.SpaceBetweenFlexbox, null, /*#__PURE__*/_react["default"].createElement(_styledComponents.SBFlexboxItem, null, /*#__PURE__*/_react["default"].createElement(_styledComponents.PanelLabel, null, /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+            id: "panel.text.textAnchor"
+          })), /*#__PURE__*/_react["default"].createElement(_itemSelector["default"], (0, _extends2["default"])({}, _constants.LAYER_TEXT_CONFIGS.textAnchor, {
+            selectedItems: tl.anchor,
+            onChange: function onChange(val) {
+              return updateLayerTextLabel(idx, 'anchor', val);
+            }
+          }))), /*#__PURE__*/_react["default"].createElement(_styledComponents.SBFlexboxItem, null, /*#__PURE__*/_react["default"].createElement(_styledComponents.PanelLabel, null, /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+            id: "panel.text.alignment"
+          })), /*#__PURE__*/_react["default"].createElement(_itemSelector["default"], (0, _extends2["default"])({}, _constants.LAYER_TEXT_CONFIGS.textAlignment, {
+            selectedItems: tl.alignment,
+            onChange: function onChange(val) {
+              return updateLayerTextLabel(idx, 'alignment', val);
+            }
+          }))))));
+        }), /*#__PURE__*/_react["default"].createElement(_styledComponents.SidePanelSection, null, /*#__PURE__*/_react["default"].createElement(_styledComponents.Button, {
+          link: true,
+          onClick: function onClick() {
+            return updateLayerTextLabel(textLabel.length, '', null);
+          }
+        }, /*#__PURE__*/_react["default"].createElement(_icons.Add, {
+          height: "12px"
+        }), /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+          id: "panel.text.addMoreLabel"
+        })))));
+      }
+    }]);
+    return TextLabelPanel;
+  }(_react.Component);
+
+  return TextLabelPanel;
+}
+
+var _default = TextLabelPanelFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/side-panel/layer-panel/text-label-panel.tsx"],"names":["TextLabelPanelFactory","deps","RangeSliderFactory","LayerConfigGroupFactory","FieldSelectorFactory","RangeSlider","LayerConfigGroup","FieldSelector","TextLabelPanel","props","updateLayerTextLabel","textLabel","fields","currentFields","map","tl","field","name","filter","d","Boolean","selected","idx","labelId","v","LAYER_TEXT_CONFIGS","fontSize","size","selectedColor","color","setColor","textAnchor","anchor","val","textAlignment","alignment","length","Component"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport React, {Component} from 'react';\nimport {FormattedMessage} from '@kepler.gl/localization';\n\nimport {\n  Button,\n  PanelLabel,\n  SBFlexboxItem,\n  SidePanelSection,\n  SpaceBetweenFlexbox\n} from '../../common/styled-components';\nimport {Add} from '../../common/icons';\nimport ColorSelector from './color-selector';\nimport ItemSelector from '../../common/item-selector/item-selector';\nimport LayerConfigGroupFactory, {\n  ConfigGroupCollapsibleContent,\n  ConfigGroupCollapsibleHeader\n} from './layer-config-group';\nimport RangeSliderFactory from '../../common/range-slider';\n\nimport FieldSelectorFactory from '../../common/field-selector';\nimport {RGBColor, LayerTextLabel, Field} from '@kepler.gl/types';\nimport {LAYER_TEXT_CONFIGS} from '@kepler.gl/constants';\n\ntype TextLabelPanelProps = {\n  fields: Field[];\n  textLabel: LayerTextLabel[];\n  updateLayerTextLabel: (idx: number | 'all', prop: string, value: any) => void;\n};\n\nTextLabelPanelFactory.deps = [RangeSliderFactory, LayerConfigGroupFactory, FieldSelectorFactory];\n\nfunction TextLabelPanelFactory(\n  RangeSlider: ReturnType<typeof RangeSliderFactory>,\n  LayerConfigGroup: ReturnType<typeof LayerConfigGroupFactory>,\n  FieldSelector: ReturnType<typeof FieldSelectorFactory>\n): React.ComponentType<TextLabelPanelProps> {\n  class TextLabelPanel extends Component<TextLabelPanelProps> {\n    render() {\n      const {updateLayerTextLabel, textLabel, fields} = this.props;\n      const currentFields = textLabel.map(tl => tl.field && tl.field.name).filter(d => Boolean(d));\n\n      return (\n        <LayerConfigGroup label={'panel.text.label'} collapsible>\n          <ConfigGroupCollapsibleHeader>\n            <FieldSelector\n              fields={fields}\n              value={currentFields as string[]}\n              onSelect={selected => updateLayerTextLabel('all', 'fields', selected)}\n              multiSelect\n            />\n          </ConfigGroupCollapsibleHeader>\n          <ConfigGroupCollapsibleContent>\n            {textLabel.map((tl, idx) => (\n              <div key={tl.field ? tl.field.name : `null-${idx}`}>\n                <PanelLabel>\n                  <FormattedMessage id={'panel.text.labelWithId'} values={{labelId: idx + 1}} />\n                </PanelLabel>\n                <SidePanelSection>\n                  <FieldSelector\n                    fields={fields}\n                    value={(tl.field && tl.field.name) || 'placeholder.selectField'}\n                    placeholder={'placeholder.empty'}\n                    onSelect={v => updateLayerTextLabel(idx, 'field', v)}\n                    erasable\n                  />\n                </SidePanelSection>\n                <SidePanelSection>\n                  <PanelLabel>\n                    <FormattedMessage id=\"panel.text.fontSize\" />\n                  </PanelLabel>\n                  <RangeSlider\n                    {...LAYER_TEXT_CONFIGS.fontSize}\n                    value1={tl.size}\n                    isRanged={false}\n                    onChange={v => updateLayerTextLabel(idx, 'size', v[1])}\n                  />\n                </SidePanelSection>\n                <SidePanelSection>\n                  <PanelLabel>\n                    <FormattedMessage id=\"panel.text.fontColor\" />\n                  </PanelLabel>\n                  <ColorSelector\n                    colorSets={[\n                      {\n                        selectedColor: tl.color,\n                        setColor: (v: RGBColor) => updateLayerTextLabel(idx, 'color', v)\n                      }\n                    ]}\n                  />\n                </SidePanelSection>\n                <SidePanelSection>\n                  <SpaceBetweenFlexbox>\n                    <SBFlexboxItem>\n                      <PanelLabel>\n                        <FormattedMessage id=\"panel.text.textAnchor\" />\n                      </PanelLabel>\n                      <ItemSelector\n                        {...LAYER_TEXT_CONFIGS.textAnchor}\n                        selectedItems={tl.anchor}\n                        onChange={val => updateLayerTextLabel(idx, 'anchor', val)}\n                      />\n                    </SBFlexboxItem>\n                    <SBFlexboxItem>\n                      <PanelLabel>\n                        <FormattedMessage id=\"panel.text.alignment\" />\n                      </PanelLabel>\n                      <ItemSelector\n                        {...LAYER_TEXT_CONFIGS.textAlignment}\n                        selectedItems={tl.alignment}\n                        onChange={val => updateLayerTextLabel(idx, 'alignment', val)}\n                      />\n                    </SBFlexboxItem>\n                  </SpaceBetweenFlexbox>\n                </SidePanelSection>\n              </div>\n            ))}\n            <SidePanelSection>\n              <Button link onClick={() => updateLayerTextLabel(textLabel.length, '', null)}>\n                <Add height=\"12px\" />\n                <FormattedMessage id=\"panel.text.addMoreLabel\" />\n              </Button>\n            </SidePanelSection>\n          </ConfigGroupCollapsibleContent>\n        </LayerConfigGroup>\n      );\n    }\n  }\n\n  return TextLabelPanel;\n}\n\nexport default TextLabelPanelFactory;\n"]}