@kepler.gl/components 3.0.0-alpha.0

package/dist/container.d.ts

@@ -0,0 +1,39 @@
+import React, { ComponentType } from 'react';
+import { ConnectedProps } from 'react-redux';
+import KeplerGlFactory from './kepler-gl';
+import { KeplerGlState } from '@kepler.gl/reducers';
+export declare const ERROR_MSG: {
+    noState: string;
+};
+declare const connector: import("react-redux").InferableComponentEnhancerWithProps<{
+    id: string;
+    mapboxApiAccessToken: string;
+    mapboxApiUrl?: string | undefined;
+    mapStylesReplaceDefault?: boolean | undefined;
+    initialUiState?: object | undefined;
+    width: number;
+    mint?: boolean | undefined;
+    getState: (state: any) => KeplerGlState;
+    state: any;
+} & {
+    dispatch: React.Dispatch<any>;
+}, ContainerProps>;
+declare type ContainerProps = {
+    id: string;
+    mapboxApiAccessToken: string;
+    mapboxApiUrl?: string;
+    mapStylesReplaceDefault?: boolean;
+    initialUiState?: object;
+    width: number;
+    mint?: boolean;
+    getState: (state: any) => KeplerGlState;
+};
+declare type PropsFromRedux = ConnectedProps<typeof connector> & ContainerProps;
+export declare function ContainerFactory(KeplerGl: ReturnType<typeof KeplerGlFactory>): ComponentType<PropsFromRedux>;
+export declare namespace ContainerFactory {
+    var deps: (typeof KeplerGlFactory)[];
+}
+export declare const appInjector: import("./injector").InjectorType;
+export declare function injectComponents(recipes?: never[]): any;
+declare const InjectedContainer: any;
+export default InjectedContainer;

package/dist/container.js

@@ -0,0 +1,242 @@
+// 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.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 _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 _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 _actions = require("@kepler.gl/actions");
+
+var _utils = require("@kepler.gl/utils");
+
+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; } }
+
+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 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;
+
+var mapStateToProps = function mapStateToProps(state, props) {
+  return _objectSpread({
+    state: state
+  }, props);
+};
+
+var dispatchToProps = function dispatchToProps(dispatch) {
+  return {
+    dispatch: dispatch
+  };
+};
+
+var connector = (0, _reactRedux.connect)(mapStateToProps, dispatchToProps);
+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);
+
+    function Container() {
+      var _this;
+
+      (0, _classCallCheck2["default"])(this, Container);
+
+      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), "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];
+        };
+      }));
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "getDispatch", (0, _lodash["default"])(function (id, dispatch) {
+        return (0, _actions.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, _actions.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, _utils.notNullorUndefined)(prevProps.id) && (0, _utils.notNullorUndefined)(this.props.id) && prevProps.id !== this.props.id) {
+          this.props.dispatch((0, _actions.renameEntry)(prevProps.id, this.props.id));
+        }
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        if (this.props.mint !== false) {
+          // delete entry in reducer
+          this.props.dispatch((0, _actions.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
+  });
+  return connector(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/container.tsx"],"names":["ERROR_MSG","noState","mapStateToProps","state","props","dispatchToProps","dispatch","connector","ContainerFactory","deps","KeplerGlFactory","KeplerGl","Container","id","getState","Console","error","mint","mapboxApiAccessToken","mapboxApiUrl","mapStylesReplaceDefault","initialUiState","prevProps","selector","getSelector","getDispatch","Component","keplerGl","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, ComponentType, Dispatch} from 'react';\nimport {connect, ConnectedProps} 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';\n\nimport {registerEntry, deleteEntry, renameEntry, forwardTo} from '@kepler.gl/actions';\nimport {notNullorUndefined} from '@kepler.gl/utils';\nimport {KeplerGlState} from '@kepler.gl/reducers';\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\nconst mapStateToProps = (state: any, props: ContainerProps) => ({state, ...props});\nconst dispatchToProps = (dispatch: Dispatch<any>) => ({dispatch});\nconst connector = connect(mapStateToProps, dispatchToProps);\n\ntype ContainerProps = {\n  id: string;\n  mapboxApiAccessToken: string;\n  mapboxApiUrl?: string;\n  mapStylesReplaceDefault?: boolean;\n  initialUiState?: object;\n  width: number;\n  mint?: boolean;\n  getState: (state: any) => KeplerGlState;\n};\n\ntype PropsFromRedux = ConnectedProps<typeof connector> & ContainerProps;\n\nContainerFactory.deps = [KeplerGlFactory];\n\nexport function ContainerFactory(\n  KeplerGl: ReturnType<typeof KeplerGlFactory>\n): ComponentType<PropsFromRedux> {\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\n  class Container extends Component<PropsFromRedux> {\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    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    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    getDispatch = memoize((id, dispatch) => forwardTo(id, dispatch));\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  return connector(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/context.d.ts

@@ -0,0 +1,16 @@
+import React, { ReactNode, ReactElement } from 'react';
+declare const KeplerGlContext: React.Context<{
+    selector: (state: any) => any;
+    id: string;
+}>;
+export declare const FeatureFlagsContext: React.Context<object | null>;
+export declare type FeatureFlags = {
+    [key: string]: string | boolean;
+};
+export declare type FeatureFlagsContextProviderProps = {
+    children: ReactNode;
+    featureFlags?: FeatureFlags;
+};
+export declare const FeatureFlagsContextProvider: (props: FeatureFlagsContextProviderProps) => ReactElement;
+export declare const RootContext: React.Context<React.RefObject<HTMLDivElement> | null>;
+export default KeplerGlContext;

package/dist/context.js

@@ -0,0 +1,53 @@
+// 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");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.RootContext = exports.FeatureFlagsContextProvider = exports.FeatureFlagsContext = void 0;
+
+var _react = _interopRequireWildcard(require("react"));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 FeatureFlagsContext = /*#__PURE__*/(0, _react.createContext)({});
+exports.FeatureFlagsContext = FeatureFlagsContext;
+
+var FeatureFlagsContextProvider = function FeatureFlagsContextProvider(props) {
+  return /*#__PURE__*/_react["default"].createElement(FeatureFlagsContext.Provider, {
+    value: props.featureFlags || null
+  }, props.children);
+};
+
+exports.FeatureFlagsContextProvider = FeatureFlagsContextProvider;
+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/editor/constants.d.ts

@@ -0,0 +1,17 @@
+export declare const RENDER_STATE: {
+    INACTIVE: string;
+    UNCOMMITTED: string;
+    SELECTED: string;
+    HOVERED: string;
+};
+export declare const RENDER_TYPE: {
+    POINT: string;
+    LINE_STRING: string;
+    POLYGON: string;
+    RECTANGLE: string;
+};
+export declare const COLORS: {
+    PRIMARY: string;
+    SECONDARY: string;
+    TERTIARY: string;
+};

package/dist/editor/constants.js

@@ -0,0 +1,47 @@
+// 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";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.COLORS = exports.RENDER_TYPE = exports.RENDER_STATE = void 0;// 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/editor/editor.d.ts

@@ -0,0 +1,30 @@
+import React, { CSSProperties } from 'react';
+import FeatureActionPanelFactory, { FeatureActionPanelProps } from './feature-action-panel';
+import { Layer } from '@kepler.gl/layers';
+import { Filter } from '@kepler.gl/types';
+import { Feature } from '@nebula.gl/edit-modes';
+import { Datasets } from '@kepler.gl/table';
+interface EditorProps {
+    filters: Filter[];
+    layers: Layer[];
+    datasets: Datasets;
+    editor: {
+        selectedFeature: Feature;
+        mode: string;
+    };
+    layersToRender: Record<string, Layer>;
+    index: number;
+    className: string;
+    clickRadius: number;
+    style: CSSProperties;
+    isEnabled: boolean;
+    onSelect: (f: Feature | null) => void;
+    onUpdate: (f: Feature[]) => void;
+    onDeleteFeature: (f: Feature) => void;
+    onTogglePolygonFilter: (l: Layer, f: Feature) => void;
+}
+declare function EditorFactory(FeatureActionPanel: React.FC<FeatureActionPanelProps>): React.ComponentClass<EditorProps>;
+declare namespace EditorFactory {
+    var deps: (typeof FeatureActionPanelFactory)[];
+}
+export default EditorFactory;