@carto/kepler.gl 0.0.1-alpha.map-libre

package/dist/components/container.js

@@ -0,0 +1,217 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ContainerFactory = ContainerFactory;
+exports.injectComponents = injectComponents;
+exports["default"] = exports.appInjector = exports.ERROR_MSG = 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 _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _reactRedux = require("react-redux");
+
+var _lodash = _interopRequireDefault(require("lodash.memoize"));
+
+var _window = require("global/window");
+
+var _injector = require("./injector");
+
+var _keplerGl = _interopRequireDefault(require("./kepler-gl"));
+
+var _actionWrapper = require("../actions/action-wrapper");
+
+var _identityActions = require("../actions/identity-actions");
+
+var _dataUtils = require("../utils/data-utils");
+
+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; }
+
+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; } }
+
+var ERROR_MSG = {
+  noState: "kepler.gl state does not exist. " + "You might forget to mount keplerGlReducer in your root reducer." + "If it is not mounted as state.keplerGl by default, you need to provide getState as a prop"
+};
+exports.ERROR_MSG = ERROR_MSG;
+ContainerFactory.deps = [_keplerGl["default"]];
+
+function ContainerFactory(KeplerGl) {
+  /** @lends KeplerGl */
+
+  /**
+    * Main Kepler.gl Component
+    * @param {Object} props
+    *
+    * @param {string} props.id - _required_
+    *
+    * - Default: `map`
+    * The id of this KeplerGl instance. `id` is required if you have multiple
+    * KeplerGl instances in your app. It defines the prop name of the KeplerGl state that is
+    * stored in the KeplerGl reducer. For example, the state of the KeplerGl component with id `foo` is
+    * stored in `state.keplerGl.foo`.
+    *
+    * In case you create multiple kepler.gl instances using the same id, the kepler.gl state defined by the entry will be
+    * overridden by the latest instance and reset to a blank state.
+    * @param {string} props.mapboxApiAccessToken - _required_
+    * @param {string} props.mapboxApiUrl - _optional_
+    * @param {Boolean} props.mapStylesReplaceDefault - _optional_
+    * @param {object} props.initialUiState - _optional_
+     * You can create a free account at [www.mapbox.com](www.mapbox.com) and create a token at
+    * [www.mapbox.com/account/access-tokens](www.mapbox.com/account/access-tokens)
+    *
+    *
+    * @param {Number} props.width - _required_ Width of the KeplerGl UI.
+    * @public
+   */
+  var Container = /*#__PURE__*/function (_Component) {
+    (0, _inherits2["default"])(Container, _Component);
+
+    var _super = _createSuper(Container);
+
+    // default id and address if not provided
+    function Container(props, ctx) {
+      var _this;
+
+      (0, _classCallCheck2["default"])(this, Container);
+      _this = _super.call(this, props, ctx);
+      _this.getSelector = (0, _lodash["default"])(function (id, getState) {
+        return function (state) {
+          if (!getState(state)) {
+            // log error
+            _window.console.error(ERROR_MSG.noState);
+
+            return null;
+          }
+
+          return getState(state)[id];
+        };
+      });
+      _this.getDispatch = (0, _lodash["default"])(function (id, dispatch) {
+        return (0, _actionWrapper.forwardTo)(id, dispatch);
+      });
+      return _this;
+    }
+
+    (0, _createClass2["default"])(Container, [{
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        var _this$props = this.props,
+            id = _this$props.id,
+            mint = _this$props.mint,
+            mapboxApiAccessToken = _this$props.mapboxApiAccessToken,
+            mapboxApiUrl = _this$props.mapboxApiUrl,
+            mapStylesReplaceDefault = _this$props.mapStylesReplaceDefault,
+            initialUiState = _this$props.initialUiState; // add a new entry to reducer
+
+        this.props.dispatch((0, _identityActions.registerEntry)({
+          id: id,
+          mint: mint,
+          mapboxApiAccessToken: mapboxApiAccessToken,
+          mapboxApiUrl: mapboxApiUrl,
+          mapStylesReplaceDefault: mapStylesReplaceDefault,
+          initialUiState: initialUiState
+        }));
+      }
+    }, {
+      key: "componentDidUpdate",
+      value: function componentDidUpdate(prevProps) {
+        // check if id has changed, if true, copy state over
+        if ((0, _dataUtils.notNullorUndefined)(prevProps.id) && (0, _dataUtils.notNullorUndefined)(this.props.id) && prevProps.id !== this.props.id) {
+          this.props.dispatch((0, _identityActions.renameEntry)(prevProps.id, this.props.id));
+        }
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        if (this.props.mint !== false) {
+          // delete entry in reducer
+          this.props.dispatch((0, _identityActions.deleteEntry)(this.props.id));
+        }
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$props2 = this.props,
+            id = _this$props2.id,
+            getState = _this$props2.getState,
+            dispatch = _this$props2.dispatch,
+            state = _this$props2.state;
+        var selector = this.getSelector(id, getState);
+
+        if (!selector || !selector(state)) {
+          // instance state hasn't been mounted yet
+          return /*#__PURE__*/_react["default"].createElement("div", null);
+        }
+
+        return /*#__PURE__*/_react["default"].createElement(KeplerGl, (0, _extends2["default"])({}, this.props, {
+          id: id,
+          selector: selector,
+          dispatch: this.getDispatch(id, dispatch)
+        }));
+      }
+    }]);
+    return Container;
+  }(_react.Component);
+
+  (0, _defineProperty2["default"])(Container, "defaultProps", {
+    id: 'map',
+    getState: function getState(state) {
+      return state.keplerGl;
+    },
+    mint: true
+  });
+
+  var mapStateToProps = function mapStateToProps(state, props) {
+    return _objectSpread({
+      state: state
+    }, props);
+  };
+
+  var dispatchToProps = function dispatchToProps(dispatch) {
+    return {
+      dispatch: dispatch
+    };
+  };
+
+  return (0, _reactRedux.connect)(mapStateToProps, dispatchToProps)(Container);
+}
+
+var allDependencies = (0, _injector.flattenDeps)([], ContainerFactory); // provide all dependencies to appInjector
+
+var appInjector = allDependencies.reduce(function (inj, factory) {
+  return inj.provide(factory, factory);
+}, (0, _injector.injector)()); // Helper to inject custom components and return kepler.gl container
+
+exports.appInjector = appInjector;
+
+function injectComponents() {
+  var recipes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return (0, _injector.provideRecipesToInjector)(recipes, appInjector).get(ContainerFactory);
+}
+
+var InjectedContainer = appInjector.get(ContainerFactory);
+var _default = InjectedContainer;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/components/container.js"],"names":["ERROR_MSG","noState","ContainerFactory","deps","KeplerGlFactory","KeplerGl","Container","props","ctx","getSelector","id","getState","state","Console","error","getDispatch","dispatch","mint","mapboxApiAccessToken","mapboxApiUrl","mapStylesReplaceDefault","initialUiState","prevProps","selector","Component","keplerGl","mapStateToProps","dispatchToProps","allDependencies","appInjector","reduce","inj","factory","provide","injectComponents","recipes","get","InjectedContainer"],"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 {connect} from 'react-redux';\nimport memoize from 'lodash.memoize';\nimport {console as Console} from 'global/window';\nimport {injector, provideRecipesToInjector, flattenDeps} from './injector';\nimport KeplerGlFactory from './kepler-gl';\nimport {forwardTo} from 'actions/action-wrapper';\n\nimport {registerEntry, deleteEntry, renameEntry} from 'actions/identity-actions';\nimport {notNullorUndefined} from 'utils/data-utils';\n\nexport const ERROR_MSG = {\n  noState:\n    `kepler.gl state does not exist. ` +\n    `You might forget to mount keplerGlReducer in your root reducer.` +\n    `If it is not mounted as state.keplerGl by default, you need to provide getState as a prop`\n};\n\nContainerFactory.deps = [KeplerGlFactory];\n\nexport function ContainerFactory(KeplerGl) {\n  /** @lends KeplerGl */\n  /**\n    * Main Kepler.gl Component\n    * @param {Object} props\n    *\n    * @param {string} props.id - _required_\n    *\n    * - Default: `map`\n    * The id of this KeplerGl instance. `id` is required if you have multiple\n    * KeplerGl instances in your app. It defines the prop name of the KeplerGl state that is\n    * stored in the KeplerGl reducer. For example, the state of the KeplerGl component with id `foo` is\n    * stored in `state.keplerGl.foo`.\n    *\n    * In case you create multiple kepler.gl instances using the same id, the kepler.gl state defined by the entry will be\n    * overridden by the latest instance and reset to a blank state.\n    * @param {string} props.mapboxApiAccessToken - _required_\n    * @param {string} props.mapboxApiUrl - _optional_\n    * @param {Boolean} props.mapStylesReplaceDefault - _optional_\n    * @param {object} props.initialUiState - _optional_\n\n    * You can create a free account at [www.mapbox.com](www.mapbox.com) and create a token at\n    * [www.mapbox.com/account/access-tokens](www.mapbox.com/account/access-tokens)\n    *\n    *\n    * @param {Number} props.width - _required_ Width of the KeplerGl UI.\n    * @public\n   */\n  class Container extends Component {\n    // default id and address if not provided\n    static defaultProps = {\n      id: 'map',\n      getState: state => state.keplerGl,\n      mint: true\n    };\n\n    constructor(props, ctx) {\n      super(props, ctx);\n\n      this.getSelector = memoize((id, getState) => state => {\n        if (!getState(state)) {\n          // log error\n          Console.error(ERROR_MSG.noState);\n\n          return null;\n        }\n        return getState(state)[id];\n      });\n      this.getDispatch = memoize((id, dispatch) => forwardTo(id, dispatch));\n    }\n\n    componentDidMount() {\n      const {\n        id,\n        mint,\n        mapboxApiAccessToken,\n        mapboxApiUrl,\n        mapStylesReplaceDefault,\n        initialUiState\n      } = this.props;\n\n      // add a new entry to reducer\n      this.props.dispatch(\n        registerEntry({\n          id,\n          mint,\n          mapboxApiAccessToken,\n          mapboxApiUrl,\n          mapStylesReplaceDefault,\n          initialUiState\n        })\n      );\n    }\n\n    componentDidUpdate(prevProps) {\n      // check if id has changed, if true, copy state over\n      if (\n        notNullorUndefined(prevProps.id) &&\n        notNullorUndefined(this.props.id) &&\n        prevProps.id !== this.props.id\n      ) {\n        this.props.dispatch(renameEntry(prevProps.id, this.props.id));\n      }\n    }\n\n    componentWillUnmount() {\n      if (this.props.mint !== false) {\n        // delete entry in reducer\n        this.props.dispatch(deleteEntry(this.props.id));\n      }\n    }\n\n    render() {\n      const {id, getState, dispatch, state} = this.props;\n      const selector = this.getSelector(id, getState);\n\n      if (!selector || !selector(state)) {\n        // instance state hasn't been mounted yet\n        return <div />;\n      }\n\n      return (\n        <KeplerGl\n          {...this.props}\n          id={id}\n          selector={selector}\n          dispatch={this.getDispatch(id, dispatch)}\n        />\n      );\n    }\n  }\n\n  const mapStateToProps = (state, props) => ({state, ...props});\n  const dispatchToProps = dispatch => ({dispatch});\n  return connect(mapStateToProps, dispatchToProps)(Container);\n}\n\nconst allDependencies = flattenDeps([], ContainerFactory);\n\n// provide all dependencies to appInjector\nexport const appInjector = allDependencies.reduce(\n  (inj, factory) => inj.provide(factory, factory),\n  injector()\n);\n\n// Helper to inject custom components and return kepler.gl container\nexport function injectComponents(recipes = []) {\n  return provideRecipesToInjector(recipes, appInjector).get(ContainerFactory);\n}\n\nconst InjectedContainer = appInjector.get(ContainerFactory);\n\nexport default InjectedContainer;\n"]}

package/dist/components/context.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.RootContext = void 0;
+
+var _react = require("react");
+
+// 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.
+var identity = function identity(state) {
+  return state;
+}; // New Context API only supported after 16.3
+
+
+var KeplerGlContext = /*#__PURE__*/(0, _react.createContext)({
+  selector: identity,
+  id: 'map'
+});
+var RootContext = /*#__PURE__*/(0, _react.createContext)(null);
+exports.RootContext = RootContext;
+var _default = KeplerGlContext;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/components/editor/constants.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.COLORS = exports.RENDER_TYPE = exports.RENDER_STATE = void 0;
+// 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.
+// Copied from react-map-gl-draw until it gets exported
+var RENDER_STATE = {
+  INACTIVE: 'INACTIVE',
+  UNCOMMITTED: 'UNCOMMITTED',
+  SELECTED: 'SELECTED',
+  HOVERED: 'HOVERED'
+};
+exports.RENDER_STATE = RENDER_STATE;
+var RENDER_TYPE = {
+  POINT: 'Point',
+  LINE_STRING: 'LineString',
+  POLYGON: 'Polygon',
+  RECTANGLE: 'Rectangle'
+};
+exports.RENDER_TYPE = RENDER_TYPE;
+var COLORS = {
+  PRIMARY: '#26B5F2',
+  SECONDARY: '#ffff00',
+  TERTIARY: '#6c6c6c'
+};
+exports.COLORS = COLORS;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/components/editor/editor.js

@@ -0,0 +1,274 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = EditorFactory;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+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 _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _reactMapGlDraw = require("react-map-gl-draw");
+
+var _window = _interopRequireDefault(require("global/window"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _lodash = _interopRequireDefault(require("lodash.get"));
+
+var _reselect = require("reselect");
+
+var _featureActionPanel = _interopRequireDefault(require("./feature-action-panel"));
+
+var _defaultSettings = require("../../constants/default-settings");
+
+var _featureStyles = require("./feature-styles");
+
+var _handleStyle = require("./handle-style");
+
+var _keyevent = _interopRequireDefault(require("../../constants/keyevent"));
+
+var _templateObject;
+
+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; }
+
+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; } }
+
+var StyledWrapper = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  cursor: ", ";\n  position: relative;\n"])), function (props) {
+  return props.editor.mode === _defaultSettings.EDITOR_MODES.EDIT ? 'pointer' : 'crosshair';
+});
+
+var editorLayerFilter = function editorLayerFilter(layer) {
+  return _defaultSettings.EDITOR_AVAILABLE_LAYERS.includes(layer.type);
+};
+
+EditorFactory.deps = [_featureActionPanel["default"]];
+
+function EditorFactory(FeatureActionPanel) {
+  var Editor = /*#__PURE__*/function (_Component) {
+    (0, _inherits2["default"])(Editor, _Component);
+
+    var _super = _createSuper(Editor);
+
+    function Editor() {
+      var _this;
+
+      (0, _classCallCheck2["default"])(this, Editor);
+
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      _this = _super.call.apply(_super, [this].concat(args));
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "state", {
+        showActions: false,
+        lastPosition: null
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "layerSelector", function (props) {
+        return props.layers;
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "layersToRenderSelector", function (props) {
+        return props.layersToRender;
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "filterSelector", function (props) {
+        return props.filters;
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "selectedFeatureIdSelector", function (props) {
+        return (0, _lodash["default"])(props, ['editor', 'selectedFeature', 'id']);
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "editorFeatureSelector", function (props) {
+        return (0, _lodash["default"])(props, ['editor', 'features']);
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "currentFilterSelector", (0, _reselect.createSelector)(_this.filterSelector, _this.selectedFeatureIdSelector, function (filters, selectedFeatureId) {
+        return filters.find(function (f) {
+          return f.value && f.value.id === selectedFeatureId;
+        });
+      }));
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "availableLayersSeletor", (0, _reselect.createSelector)(_this.layerSelector, _this.layersToRenderSelector, function (layers, layersToRender) {
+        return layers.filter(editorLayerFilter).filter(function (layer) {
+          return layersToRender[layer.id];
+        });
+      }));
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "allFeaturesSelector", (0, _reselect.createSelector)(_this.filterSelector, _this.editorFeatureSelector, function (filters, editorFeatures) {
+        return filters.filter(function (f) {
+          return f.type === _defaultSettings.FILTER_TYPES.polygon;
+        }).map(function (f) {
+          return f.value;
+        }).concat(editorFeatures);
+      }));
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_onKeyPressed", function (event) {
+        var isEnabled = _this.props.isEnabled;
+
+        if (!isEnabled) {
+          return;
+        }
+
+        switch (event.keyCode) {
+          case _keyevent["default"].DOM_VK_DELETE:
+          case _keyevent["default"].DOM_VK_BACK_SPACE:
+            _this._onDeleteSelectedFeature();
+
+            break;
+
+          case _keyevent["default"].DOM_VK_ESCAPE:
+            _this.props.onSelect(null);
+
+            break;
+
+          default:
+            break;
+        }
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_onSelect", function (_ref) {
+        var selectedFeatureId = _ref.selectedFeatureId,
+            sourceEvent = _ref.sourceEvent;
+
+        var allFeatures = _this.allFeaturesSelector(_this.props);
+
+        _this.setState(_objectSpread({}, sourceEvent.rightButton ? {
+          showActions: true,
+          lastPosition: {
+            x: sourceEvent.changedPointers[0].offsetX,
+            y: sourceEvent.changedPointers[0].offsetY
+          }
+        } : null), function () {
+          _this.props.onSelect(allFeatures.find(function (f) {
+            return f.id === selectedFeatureId;
+          }));
+        });
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_onDeleteSelectedFeature", function () {
+        if (_this.state.showActions) {
+          _this.setState({
+            showActions: false
+          });
+        }
+
+        var editor = _this.props.editor;
+        var _editor$selectedFeatu = editor.selectedFeature,
+            selectedFeature = _editor$selectedFeatu === void 0 ? {} : _editor$selectedFeatu;
+
+        _this.props.onDeleteFeature(selectedFeature);
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_closeFeatureAction", function () {
+        _this.setState({
+          showActions: false
+        });
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_onToggleLayer", function (layer) {
+        var selectedFeature = _this.props.editor.selectedFeature;
+
+        if (!selectedFeature) {
+          return;
+        }
+
+        _this.props.onTogglePolygonFilter(layer, selectedFeature);
+      });
+      return _this;
+    }
+
+    (0, _createClass2["default"])(Editor, [{
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        _window["default"].addEventListener('keydown', this._onKeyPressed);
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        _window["default"].removeEventListener('keydown', this._onKeyPressed);
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$props = this.props,
+            className = _this$props.className,
+            clickRadius = _this$props.clickRadius,
+            datasets = _this$props.datasets,
+            editor = _this$props.editor,
+            onUpdate = _this$props.onUpdate,
+            style = _this$props.style;
+        var _this$state = this.state,
+            lastPosition = _this$state.lastPosition,
+            showActions = _this$state.showActions;
+        var selectedFeatureId = (0, _lodash["default"])(editor, ['selectedFeature', 'id']);
+        var currentFilter = this.currentFilterSelector(this.props);
+        var availableLayers = this.availableLayersSeletor(this.props);
+        var allFeatures = this.allFeaturesSelector(this.props);
+        return /*#__PURE__*/_react["default"].createElement(StyledWrapper, {
+          editor: editor,
+          className: (0, _classnames["default"])('editor', className),
+          style: style
+        }, /*#__PURE__*/_react["default"].createElement(_reactMapGlDraw.Editor, {
+          clickRadius: clickRadius,
+          mode: editor.mode,
+          features: allFeatures,
+          selectedFeatureId: selectedFeatureId,
+          onSelect: this._onSelect,
+          onUpdate: onUpdate,
+          getEditHandleShape: _handleStyle.getEditHandleShape,
+          getFeatureStyle: _featureStyles.getStyle,
+          getEditHandleStyle: _handleStyle.getStyle
+        }), showActions && Boolean(selectedFeatureId) ? /*#__PURE__*/_react["default"].createElement(FeatureActionPanel, {
+          selectedFeature: (0, _lodash["default"])(editor, ['selectedFeature']),
+          datasets: datasets,
+          layers: availableLayers,
+          currentFilter: currentFilter,
+          onClose: this._closeFeatureAction,
+          onDeleteFeature: this._onDeleteSelectedFeature,
+          onToggleLayer: this._onToggleLayer,
+          position: lastPosition
+        }) : null);
+      }
+    }]);
+    return Editor;
+  }(_react.Component);
+
+  (0, _defineProperty2["default"])(Editor, "propTypes", {
+    filters: _propTypes["default"].arrayOf(_propTypes["default"].object).isRequired,
+    layers: _propTypes["default"].arrayOf(_propTypes["default"].object).isRequired,
+    datasets: _propTypes["default"].object.isRequired,
+    editor: _propTypes["default"].object.isRequired,
+    layersToRender: _propTypes["default"].object.isRequired,
+    onSelect: _propTypes["default"].func.isRequired,
+    onUpdate: _propTypes["default"].func.isRequired,
+    onDeleteFeature: _propTypes["default"].func.isRequired,
+    onTogglePolygonFilter: _propTypes["default"].func.isRequired,
+    index: _propTypes["default"].number,
+    classnames: _propTypes["default"].string,
+    clickRadius: _propTypes["default"].number,
+    isEnabled: _propTypes["default"].bool
+  });
+  (0, _defineProperty2["default"])(Editor, "defaultProps", {
+    clickRadius: _featureStyles.DEFAULT_RADIUS
+  });
+  Editor.displayName = 'Editor';
+  return Editor;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/components/editor/editor.js"],"names":["StyledWrapper","styled","div","props","editor","mode","EDITOR_MODES","EDIT","editorLayerFilter","layer","EDITOR_AVAILABLE_LAYERS","includes","type","EditorFactory","deps","FeatureActionPanelFactory","FeatureActionPanel","Editor","showActions","lastPosition","layers","layersToRender","filters","filterSelector","selectedFeatureIdSelector","selectedFeatureId","find","f","value","id","layerSelector","layersToRenderSelector","filter","editorFeatureSelector","editorFeatures","FILTER_TYPES","polygon","map","concat","event","isEnabled","keyCode","KeyEvent","DOM_VK_DELETE","DOM_VK_BACK_SPACE","_onDeleteSelectedFeature","DOM_VK_ESCAPE","onSelect","sourceEvent","allFeatures","allFeaturesSelector","setState","rightButton","x","changedPointers","offsetX","y","offsetY","state","selectedFeature","onDeleteFeature","onTogglePolygonFilter","window","addEventListener","_onKeyPressed","removeEventListener","className","clickRadius","datasets","onUpdate","style","currentFilter","currentFilterSelector","availableLayers","availableLayersSeletor","_onSelect","getEditHandleShape","getFeatureStyle","getEditHandleStyle","Boolean","_closeFeatureAction","_onToggleLayer","Component","PropTypes","arrayOf","object","isRequired","func","index","number","classnames","string","bool","DEFAULT_RADIUS","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, {Component} from 'react';\nimport PropTypes from 'prop-types';\nimport styled from 'styled-components';\nimport {Editor as Draw} from 'react-map-gl-draw';\nimport window from 'global/window';\nimport classnames from 'classnames';\nimport get from 'lodash.get';\nimport {createSelector} from 'reselect';\n\nimport FeatureActionPanelFactory from './feature-action-panel';\nimport {FILTER_TYPES, EDITOR_MODES, EDITOR_AVAILABLE_LAYERS} from 'constants/default-settings';\n\nimport {DEFAULT_RADIUS, getStyle as getFeatureStyle} from './feature-styles';\nimport {getStyle as getEditHandleStyle, getEditHandleShape} from './handle-style';\nimport KeyEvent from 'constants/keyevent';\n\nconst StyledWrapper = styled.div`\n  cursor: ${props => (props.editor.mode === EDITOR_MODES.EDIT ? 'pointer' : 'crosshair')};\n  position: relative;\n`;\n\nconst editorLayerFilter = layer => EDITOR_AVAILABLE_LAYERS.includes(layer.type);\n\nEditorFactory.deps = [FeatureActionPanelFactory];\n\nexport default function EditorFactory(FeatureActionPanel) {\n  class Editor extends Component {\n    static propTypes = {\n      filters: PropTypes.arrayOf(PropTypes.object).isRequired,\n      layers: PropTypes.arrayOf(PropTypes.object).isRequired,\n      datasets: PropTypes.object.isRequired,\n      editor: PropTypes.object.isRequired,\n      layersToRender: PropTypes.object.isRequired,\n      onSelect: PropTypes.func.isRequired,\n      onUpdate: PropTypes.func.isRequired,\n      onDeleteFeature: PropTypes.func.isRequired,\n      onTogglePolygonFilter: PropTypes.func.isRequired,\n\n      index: PropTypes.number,\n      classnames: PropTypes.string,\n      clickRadius: PropTypes.number,\n      isEnabled: PropTypes.bool\n    };\n\n    static defaultProps = {\n      clickRadius: DEFAULT_RADIUS\n    };\n\n    state = {\n      showActions: false,\n      lastPosition: null\n    };\n\n    componentDidMount() {\n      window.addEventListener('keydown', this._onKeyPressed);\n    }\n\n    componentWillUnmount() {\n      window.removeEventListener('keydown', this._onKeyPressed);\n    }\n\n    layerSelector = props => props.layers;\n    layersToRenderSelector = props => props.layersToRender;\n    filterSelector = props => props.filters;\n    selectedFeatureIdSelector = props => get(props, ['editor', 'selectedFeature', 'id']);\n    editorFeatureSelector = props => get(props, ['editor', 'features']);\n\n    currentFilterSelector = createSelector(\n      this.filterSelector,\n      this.selectedFeatureIdSelector,\n      (filters, selectedFeatureId) => filters.find(f => f.value && f.value.id === selectedFeatureId)\n    );\n\n    availableLayersSeletor = createSelector(\n      this.layerSelector,\n      this.layersToRenderSelector,\n      (layers, layersToRender) =>\n        layers.filter(editorLayerFilter).filter(layer => {\n          return layersToRender[layer.id];\n        })\n    );\n\n    allFeaturesSelector = createSelector(\n      this.filterSelector,\n      this.editorFeatureSelector,\n      (filters, editorFeatures) =>\n        filters\n          .filter(f => f.type === FILTER_TYPES.polygon)\n          .map(f => f.value)\n          .concat(editorFeatures)\n    );\n\n    _onKeyPressed = event => {\n      const {isEnabled} = this.props;\n\n      if (!isEnabled) {\n        return;\n      }\n\n      switch (event.keyCode) {\n        case KeyEvent.DOM_VK_DELETE:\n        case KeyEvent.DOM_VK_BACK_SPACE:\n          this._onDeleteSelectedFeature();\n          break;\n        case KeyEvent.DOM_VK_ESCAPE:\n          this.props.onSelect(null);\n          break;\n        default:\n          break;\n      }\n    };\n\n    _onSelect = ({selectedFeatureId, sourceEvent}) => {\n      const allFeatures = this.allFeaturesSelector(this.props);\n      this.setState(\n        {\n          ...(sourceEvent.rightButton\n            ? {\n                showActions: true,\n                lastPosition: {\n                  x: sourceEvent.changedPointers[0].offsetX,\n                  y: sourceEvent.changedPointers[0].offsetY\n                }\n              }\n            : null)\n        },\n        () => {\n          this.props.onSelect(allFeatures.find(f => f.id === selectedFeatureId));\n        }\n      );\n    };\n\n    _onDeleteSelectedFeature = () => {\n      if (this.state.showActions) {\n        this.setState({showActions: false});\n      }\n\n      const {editor} = this.props;\n      const {selectedFeature = {}} = editor;\n      this.props.onDeleteFeature(selectedFeature);\n    };\n\n    _closeFeatureAction = () => {\n      this.setState({showActions: false});\n    };\n\n    _onToggleLayer = layer => {\n      const {selectedFeature} = this.props.editor;\n      if (!selectedFeature) {\n        return;\n      }\n\n      this.props.onTogglePolygonFilter(layer, selectedFeature);\n    };\n\n    render() {\n      const {className, clickRadius, datasets, editor, onUpdate, style} = this.props;\n\n      const {lastPosition, showActions} = this.state;\n      const selectedFeatureId = get(editor, ['selectedFeature', 'id']);\n      const currentFilter = this.currentFilterSelector(this.props);\n      const availableLayers = this.availableLayersSeletor(this.props);\n      const allFeatures = this.allFeaturesSelector(this.props);\n\n      return (\n        <StyledWrapper editor={editor} className={classnames('editor', className)} style={style}>\n          <Draw\n            clickRadius={clickRadius}\n            mode={editor.mode}\n            features={allFeatures}\n            selectedFeatureId={selectedFeatureId}\n            onSelect={this._onSelect}\n            onUpdate={onUpdate}\n            getEditHandleShape={getEditHandleShape}\n            getFeatureStyle={getFeatureStyle}\n            getEditHandleStyle={getEditHandleStyle}\n          />\n          {showActions && Boolean(selectedFeatureId) ? (\n            <FeatureActionPanel\n              selectedFeature={get(editor, ['selectedFeature'])}\n              datasets={datasets}\n              layers={availableLayers}\n              currentFilter={currentFilter}\n              onClose={this._closeFeatureAction}\n              onDeleteFeature={this._onDeleteSelectedFeature}\n              onToggleLayer={this._onToggleLayer}\n              position={lastPosition}\n            />\n          ) : null}\n        </StyledWrapper>\n      );\n    }\n  }\n\n  Editor.displayName = 'Editor';\n\n  return Editor;\n}\n"]}