@kepler.gl/components 3.3.0-alpha.1 → 3.3.0-alpha.10

package/dist/esm/container.js

@@ -0,0 +1,171 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useRef, useEffect, useMemo } from 'react';
+import { connect, useDispatch } from 'react-redux';
+import { console as Console } from 'global/window';
+import { injector, provideRecipesToInjector, flattenDeps } from './injector';
+import KeplerGlFactory from './kepler-gl';
+import { registerEntry, deleteEntry, renameEntry, forwardTo } from '@kepler.gl/actions';
+import { getApplicationConfig } from '@kepler.gl/utils';
+export 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"
+};
+var mapStateToProps = function mapStateToProps(state, props) {
+  return _objectSpread({
+    state: state
+  }, props);
+};
+var dispatchToProps = function dispatchToProps(dispatch) {
+  return {
+    dispatch: dispatch
+  };
+};
+var connector = connect(mapStateToProps, dispatchToProps);
+ContainerFactory.deps = [KeplerGlFactory];
+export 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
+   */
+
+  function usePreviousId(value) {
+    var ref = useRef(undefined);
+    useEffect(function () {
+      ref.current = value;
+    });
+    return ref.current;
+  }
+  var Container = function Container(props) {
+    var _props$id = props.id,
+      id = _props$id === void 0 ? 'map' : _props$id,
+      _props$getState = props.getState,
+      getState = _props$getState === void 0 ? function (state) {
+        return state.keplerGl;
+      } : _props$getState,
+      _props$mint = props.mint,
+      mint = _props$mint === void 0 ? true : _props$mint,
+      mapboxApiAccessToken = props.mapboxApiAccessToken,
+      mapboxApiUrl = props.mapboxApiUrl,
+      mapStylesReplaceDefault = props.mapStylesReplaceDefault,
+      initialUiState = props.initialUiState,
+      state = props.state;
+    var prevId = usePreviousId(id);
+    var dispatch = useDispatch();
+    useEffect(function () {
+      // add a new entry to reducer
+      dispatch(registerEntry({
+        id: id,
+        mint: mint,
+        mapboxApiAccessToken: mapboxApiAccessToken,
+        mapboxApiUrl: mapboxApiUrl,
+        mapStylesReplaceDefault: mapStylesReplaceDefault,
+        initialUiState: initialUiState
+      }));
+
+      // initialize plugins
+      if (getApplicationConfig().plugins.length) {
+        getApplicationConfig().plugins.forEach(/*#__PURE__*/function () {
+          var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(plugin) {
+            return _regeneratorRuntime.wrap(function _callee$(_context) {
+              while (1) switch (_context.prev = _context.next) {
+                case 0:
+                  _context.next = 2;
+                  return plugin.init();
+                case 2:
+                case "end":
+                  return _context.stop();
+              }
+            }, _callee);
+          }));
+          return function (_x) {
+            return _ref.apply(this, arguments);
+          };
+        }());
+      }
+
+      // cleanup
+      return function () {
+        if (mint !== false) {
+          // delete entry in reducer
+          dispatch(deleteEntry(id));
+        }
+      };
+    }, [id, dispatch, initialUiState, mapStylesReplaceDefault, mapboxApiAccessToken, mapboxApiUrl, mint]);
+    useEffect(function () {
+      // check if id has changed, if true, copy state over
+      if (prevId && id && prevId !== id) {
+        dispatch(renameEntry(prevId, id));
+      }
+    }, [dispatch, prevId, id]);
+    var stateSelector = useMemo(function () {
+      return function (keplerState) {
+        if (!getState(keplerState)) {
+          // log error
+          Console.error(ERROR_MSG.noState);
+          return null;
+        }
+        return getState(keplerState)[id];
+      };
+    }, [id, getState]);
+    var forwardDispatch = useMemo(function () {
+      return forwardTo(id, dispatch);
+    }, [id, dispatch]);
+
+    // const selector = getSelector(id, getState);
+
+    if (!stateSelector || !stateSelector(state)) {
+      // instance state hasn't been mounted yet
+      return /*#__PURE__*/React.createElement("div", null);
+    }
+    return /*#__PURE__*/React.createElement(KeplerGl, _extends({}, props, {
+      id: id,
+      selector: stateSelector,
+      dispatch: forwardDispatch
+    }));
+  };
+  return connector(Container);
+}
+var allDependencies = flattenDeps([], ContainerFactory);
+
+// provide all dependencies to appInjector
+export var appInjector = allDependencies.reduce(function (inj, factory) {
+  return inj.provide(factory, factory);
+}, injector());
+
+// Helper to inject custom components and return kepler.gl container
+export function injectComponents() {
+  var recipes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return provideRecipesToInjector(recipes, appInjector).get(ContainerFactory);
+}
+var InjectedContainer = appInjector.get(ContainerFactory);
+export default InjectedContainer;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useRef","useEffect","useMemo","connect","useDispatch","console","Console","injector","provideRecipesToInjector","flattenDeps","KeplerGlFactory","registerEntry","deleteEntry","renameEntry","forwardTo","getApplicationConfig","ERROR_MSG","noState","mapStateToProps","state","props","_objectSpread","dispatchToProps","dispatch","connector","ContainerFactory","deps","KeplerGl","usePreviousId","value","ref","undefined","current","Container","_props$id","id","_props$getState","getState","keplerGl","_props$mint","mint","mapboxApiAccessToken","mapboxApiUrl","mapStylesReplaceDefault","initialUiState","prevId","plugins","length","forEach","_ref","_asyncToGenerator","_regeneratorRuntime","mark","_callee","plugin","wrap","_callee$","_context","prev","next","init","stop","_x","apply","arguments","stateSelector","keplerState","error","forwardDispatch","createElement","_extends","selector","allDependencies","appInjector","reduce","inj","factory","provide","injectComponents","recipes","get","InjectedContainer"],"sources":["../../src/container.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useRef, ComponentType, useEffect, useMemo} from 'react';\nimport {connect, ConnectedProps, useDispatch} from 'react-redux';\nimport type {Dispatch} from 'redux';\n\nimport {console as Console} from 'global/window';\nimport {injector, provideRecipesToInjector, flattenDeps} from './injector';\nimport KeplerGlFactory from './kepler-gl';\nimport {registerEntry, deleteEntry, renameEntry, forwardTo} from '@kepler.gl/actions';\nimport {KeplerGlState} from '@kepler.gl/reducers';\nimport {getApplicationConfig} from '@kepler.gl/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\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  function usePreviousId(value) {\n    const ref = useRef<string | undefined>(undefined);\n    useEffect(() => {\n      ref.current = value;\n    });\n    return ref.current;\n  }\n\n  const Container: React.FC<PropsFromRedux> = props => {\n    const {\n      // default id and address if not provided\n      id = 'map',\n      getState = state => state.keplerGl,\n      mint = true,\n      mapboxApiAccessToken,\n      mapboxApiUrl,\n      mapStylesReplaceDefault,\n      initialUiState,\n      state\n    } = props;\n    const prevId = usePreviousId(id);\n    const dispatch = useDispatch<Dispatch>();\n\n    useEffect(() => {\n      // add a new entry to reducer\n      dispatch(\n        registerEntry({\n          id,\n          mint,\n          mapboxApiAccessToken,\n          mapboxApiUrl,\n          mapStylesReplaceDefault,\n          initialUiState\n        })\n      );\n\n      // initialize plugins\n      if (getApplicationConfig().plugins.length) {\n        getApplicationConfig().plugins.forEach(async plugin => {\n          await plugin.init();\n        });\n      }\n\n      // cleanup\n      return () => {\n        if (mint !== false) {\n          // delete entry in reducer\n          dispatch(deleteEntry(id));\n        }\n      };\n    }, [\n      id,\n      dispatch,\n      initialUiState,\n      mapStylesReplaceDefault,\n      mapboxApiAccessToken,\n      mapboxApiUrl,\n      mint\n    ]);\n\n    useEffect(() => {\n      // check if id has changed, if true, copy state over\n      if (prevId && id && prevId !== id) {\n        dispatch(renameEntry(prevId, id));\n      }\n    }, [dispatch, prevId, id]);\n\n    const stateSelector = useMemo(\n      () => keplerState => {\n        if (!getState(keplerState)) {\n          // log error\n          Console.error(ERROR_MSG.noState);\n\n          return null;\n        }\n        return getState(keplerState)[id];\n      },\n      [id, getState]\n    );\n    const forwardDispatch = useMemo(() => forwardTo(id, dispatch), [id, dispatch]);\n\n    // const selector = getSelector(id, getState);\n\n    if (!stateSelector || !stateSelector(state)) {\n      // instance state hasn't been mounted yet\n      return <div />;\n    }\n\n    return <KeplerGl {...props} id={id} selector={stateSelector} dispatch={forwardDispatch} />;\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"],"mappings":";;;;;;AAAA;AACA;;AAEA,OAAOA,KAAK,IAAGC,MAAM,EAAiBC,SAAS,EAAEC,OAAO,QAAO,OAAO;AACtE,SAAQC,OAAO,EAAkBC,WAAW,QAAO,aAAa;AAGhE,SAAQC,OAAO,IAAIC,OAAO,QAAO,eAAe;AAChD,SAAQC,QAAQ,EAAEC,wBAAwB,EAAEC,WAAW,QAAO,YAAY;AAC1E,OAAOC,eAAe,MAAM,aAAa;AACzC,SAAQC,aAAa,EAAEC,WAAW,EAAEC,WAAW,EAAEC,SAAS,QAAO,oBAAoB;AAErF,SAAQC,oBAAoB,QAAO,kBAAkB;AAErD,OAAO,IAAMC,SAAS,GAAG;EACvBC,OAAO,EACL,sGACiE;AAErE,CAAC;AAED,IAAMC,eAAe,GAAG,SAAlBA,eAAeA,CAAIC,KAAU,EAAEC,KAAqB;EAAA,OAAAC,aAAA;IAAOF,KAAK,EAALA;EAAK,GAAKC,KAAK;AAAA,CAAE;AAClF,IAAME,eAAe,GAAG,SAAlBA,eAAeA,CAAIC,QAAuB;EAAA,OAAM;IAACA,QAAQ,EAARA;EAAQ,CAAC;AAAA,CAAC;AACjE,IAAMC,SAAS,GAAGrB,OAAO,CAACe,eAAe,EAAEI,eAAe,CAAC;AAe3DG,gBAAgB,CAACC,IAAI,GAAG,CAAChB,eAAe,CAAC;AAEzC,OAAO,SAASe,gBAAgBA,CAC9BE,QAA4C,EACb;EAC/B;EACA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;EAGE,SAASC,aAAaA,CAACC,KAAK,EAAE;IAC5B,IAAMC,GAAG,GAAG9B,MAAM,CAAqB+B,SAAS,CAAC;IACjD9B,SAAS,CAAC,YAAM;MACd6B,GAAG,CAACE,OAAO,GAAGH,KAAK;IACrB,CAAC,CAAC;IACF,OAAOC,GAAG,CAACE,OAAO;EACpB;EAEA,IAAMC,SAAmC,GAAG,SAAtCA,SAAmCA,CAAGb,KAAK,EAAI;IACnD,IAAAc,SAAA,GAUId,KAAK,CARPe,EAAE;MAAFA,EAAE,GAAAD,SAAA,cAAG,KAAK,GAAAA,SAAA;MAAAE,eAAA,GAQRhB,KAAK,CAPPiB,QAAQ;MAARA,QAAQ,GAAAD,eAAA,cAAG,UAAAjB,KAAK;QAAA,OAAIA,KAAK,CAACmB,QAAQ;MAAA,IAAAF,eAAA;MAAAG,WAAA,GAOhCnB,KAAK,CANPoB,IAAI;MAAJA,IAAI,GAAAD,WAAA,cAAG,IAAI,GAAAA,WAAA;MACXE,oBAAoB,GAKlBrB,KAAK,CALPqB,oBAAoB;MACpBC,YAAY,GAIVtB,KAAK,CAJPsB,YAAY;MACZC,uBAAuB,GAGrBvB,KAAK,CAHPuB,uBAAuB;MACvBC,cAAc,GAEZxB,KAAK,CAFPwB,cAAc;MACdzB,KAAK,GACHC,KAAK,CADPD,KAAK;IAEP,IAAM0B,MAAM,GAAGjB,aAAa,CAACO,EAAE,CAAC;IAChC,IAAMZ,QAAQ,GAAGnB,WAAW,CAAW,CAAC;IAExCH,SAAS,CAAC,YAAM;MACd;MACAsB,QAAQ,CACNZ,aAAa,CAAC;QACZwB,EAAE,EAAFA,EAAE;QACFK,IAAI,EAAJA,IAAI;QACJC,oBAAoB,EAApBA,oBAAoB;QACpBC,YAAY,EAAZA,YAAY;QACZC,uBAAuB,EAAvBA,uBAAuB;QACvBC,cAAc,EAAdA;MACF,CAAC,CACH,CAAC;;MAED;MACA,IAAI7B,oBAAoB,CAAC,CAAC,CAAC+B,OAAO,CAACC,MAAM,EAAE;QACzChC,oBAAoB,CAAC,CAAC,CAAC+B,OAAO,CAACE,OAAO;UAAA,IAAAC,IAAA,GAAAC,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAAC,QAAMC,MAAM;YAAA,OAAAH,mBAAA,CAAAI,IAAA,UAAAC,SAAAC,QAAA;cAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;gBAAA;kBAAAF,QAAA,CAAAE,IAAA;kBAAA,OAC3CL,MAAM,CAACM,IAAI,CAAC,CAAC;gBAAA;gBAAA;kBAAA,OAAAH,QAAA,CAAAI,IAAA;cAAA;YAAA,GAAAR,OAAA;UAAA,CACpB;UAAA,iBAAAS,EAAA;YAAA,OAAAb,IAAA,CAAAc,KAAA,OAAAC,SAAA;UAAA;QAAA,IAAC;MACJ;;MAEA;MACA,OAAO,YAAM;QACX,IAAIxB,IAAI,KAAK,KAAK,EAAE;UAClB;UACAjB,QAAQ,CAACX,WAAW,CAACuB,EAAE,CAAC,CAAC;QAC3B;MACF,CAAC;IACH,CAAC,EAAE,CACDA,EAAE,EACFZ,QAAQ,EACRqB,cAAc,EACdD,uBAAuB,EACvBF,oBAAoB,EACpBC,YAAY,EACZF,IAAI,CACL,CAAC;IAEFvC,SAAS,CAAC,YAAM;MACd;MACA,IAAI4C,MAAM,IAAIV,EAAE,IAAIU,MAAM,KAAKV,EAAE,EAAE;QACjCZ,QAAQ,CAACV,WAAW,CAACgC,MAAM,EAAEV,EAAE,CAAC,CAAC;MACnC;IACF,CAAC,EAAE,CAACZ,QAAQ,EAAEsB,MAAM,EAAEV,EAAE,CAAC,CAAC;IAE1B,IAAM8B,aAAa,GAAG/D,OAAO,CAC3B;MAAA,OAAM,UAAAgE,WAAW,EAAI;QACnB,IAAI,CAAC7B,QAAQ,CAAC6B,WAAW,CAAC,EAAE;UAC1B;UACA5D,OAAO,CAAC6D,KAAK,CAACnD,SAAS,CAACC,OAAO,CAAC;UAEhC,OAAO,IAAI;QACb;QACA,OAAOoB,QAAQ,CAAC6B,WAAW,CAAC,CAAC/B,EAAE,CAAC;MAClC,CAAC;IAAA,GACD,CAACA,EAAE,EAAEE,QAAQ,CACf,CAAC;IACD,IAAM+B,eAAe,GAAGlE,OAAO,CAAC;MAAA,OAAMY,SAAS,CAACqB,EAAE,EAAEZ,QAAQ,CAAC;IAAA,GAAE,CAACY,EAAE,EAAEZ,QAAQ,CAAC,CAAC;;IAE9E;;IAEA,IAAI,CAAC0C,aAAa,IAAI,CAACA,aAAa,CAAC9C,KAAK,CAAC,EAAE;MAC3C;MACA,oBAAOpB,KAAA,CAAAsE,aAAA,YAAM,CAAC;IAChB;IAEA,oBAAOtE,KAAA,CAAAsE,aAAA,CAAC1C,QAAQ,EAAA2C,QAAA,KAAKlD,KAAK;MAAEe,EAAE,EAAEA,EAAG;MAACoC,QAAQ,EAAEN,aAAc;MAAC1C,QAAQ,EAAE6C;IAAgB,EAAE,CAAC;EAC5F,CAAC;EAED,OAAO5C,SAAS,CAACS,SAAS,CAAC;AAC7B;AAEA,IAAMuC,eAAe,GAAG/D,WAAW,CAAC,EAAE,EAAEgB,gBAAgB,CAAC;;AAEzD;AACA,OAAO,IAAMgD,WAAW,GAAGD,eAAe,CAACE,MAAM,CAC/C,UAACC,GAAG,EAAEC,OAAO;EAAA,OAAKD,GAAG,CAACE,OAAO,CAACD,OAAO,EAAEA,OAAO,CAAC;AAAA,GAC/CrE,QAAQ,CAAC,CACX,CAAC;;AAED;AACA,OAAO,SAASuE,gBAAgBA,CAAA,EAAe;EAAA,IAAdC,OAAO,GAAAf,SAAA,CAAAjB,MAAA,QAAAiB,SAAA,QAAAjC,SAAA,GAAAiC,SAAA,MAAG,EAAE;EAC3C,OAAOxD,wBAAwB,CAACuE,OAAO,EAAEN,WAAW,CAAC,CAACO,GAAG,CAACvD,gBAAgB,CAAC;AAC7E;AAEA,IAAMwD,iBAAiB,GAAGR,WAAW,CAACO,GAAG,CAACvD,gBAAgB,CAAC;AAE3D,eAAewD,iBAAiB","ignoreList":[]}

package/dist/esm/context.js

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { createContext } from 'react';
+var identity = function identity(state) {
+  return state;
+};
+// New Context API only supported after 16.3
+var KeplerGlContext = /*#__PURE__*/createContext({
+  selector: identity,
+  id: 'map'
+});
+
+// TODO: breakdown this file into multiple files
+export var FeatureFlagsContext = /*#__PURE__*/createContext({});
+export var FeatureFlagsContextProvider = function FeatureFlagsContextProvider(props) {
+  return /*#__PURE__*/React.createElement(FeatureFlagsContext.Provider, {
+    value: props.featureFlags || null
+  }, props.children);
+};
+
+/**
+ * This provides keeps track of the ist cloud providers
+ * and the current selected one
+ */
+export var CloudProviderContext = /*#__PURE__*/createContext({
+  provider: null,
+  setProvider: function setProvider() {
+    return;
+  },
+  cloudProviders: []
+});
+export var RootContext = /*#__PURE__*/createContext(null);
+export default KeplerGlContext;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/dnd-context.js

@@ -0,0 +1,167 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useCallback, useMemo } from 'react';
+import styled from 'styled-components';
+import { DndContext as DndKitContext, DragOverlay, closestCenter, pointerWithin } from '@dnd-kit/core';
+import Console from 'global/console';
+import LayerPanelHeaderFactory from './side-panel/layer-panel/layer-panel-header';
+import LayerGroupHeaderFactory from './side-panel/layer-panel/layer-group-header';
+import useDndLayers from './hooks/use-dnd-layers';
+import useDndEffects from './hooks/use-dnd-effects';
+import { DND_MODIFIERS, DND_EMPTY_MODIFIERS, SORTABLE_LAYER_TYPE, SORTABLE_LAYER_GROUP_TYPE, SORTABLE_LAYER_END_TYPE, SORTABLE_EFFECT_TYPE, SORTABLE_LAYER_GROUP_DROPPABLE_TYPE } from './common/dnd-layer-items';
+export var DragItem = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  color: ", ";\n  border-radius: ", "px;\n  padding: 5px 10px;\n  display: inline;\n"])), function (props) {
+  return props.theme.textColorHl;
+}, function (props) {
+  return props.theme.radioButtonRadius;
+});
+var nop = function nop() {
+  return undefined;
+};
+
+/**
+ * Hybrid collision detection: uses closestCenter for sortable items (stable reordering
+ * without flickering) and pointerWithin for group droppable containers (reliable drop
+ * detection even when group is the last item). When dragging a group, only root-level
+ * sortable items are considered to prevent flickering from nested items.
+ */
+var layerGroupCollisionDetection = function layerGroupCollisionDetection(args) {
+  var _args$active$data;
+  var activeType = (_args$active$data = args.active.data) === null || _args$active$data === void 0 || (_args$active$data = _args$active$data.current) === null || _args$active$data === void 0 ? void 0 : _args$active$data.type;
+
+  // When dragging a group, only consider root-level sortable items (no parent)
+  if (activeType === SORTABLE_LAYER_GROUP_TYPE) {
+    var filteredArgs = _objectSpread(_objectSpread({}, args), {}, {
+      droppableContainers: args.droppableContainers.filter(function (container) {
+        var _container$data, _container$data2;
+        var type = (_container$data = container.data) === null || _container$data === void 0 || (_container$data = _container$data.current) === null || _container$data === void 0 ? void 0 : _container$data.type;
+        return type === SORTABLE_LAYER_GROUP_TYPE || type === SORTABLE_LAYER_END_TYPE || type === SORTABLE_LAYER_TYPE && !((_container$data2 = container.data) !== null && _container$data2 !== void 0 && (_container$data2 = _container$data2.current) !== null && _container$data2 !== void 0 && _container$data2.parent);
+      })
+    });
+    return closestCenter(filteredArgs);
+  }
+  var closestCenterCollisions = closestCenter(args);
+  var pointerCollisions = pointerWithin(args);
+  var groupDroppable = pointerCollisions.find(function (c) {
+    var _c$data;
+    var type = (_c$data = c.data) === null || _c$data === void 0 || (_c$data = _c$data.droppableContainer) === null || _c$data === void 0 || (_c$data = _c$data.data) === null || _c$data === void 0 || (_c$data = _c$data.current) === null || _c$data === void 0 ? void 0 : _c$data.type;
+    return type === SORTABLE_LAYER_GROUP_DROPPABLE_TYPE;
+  });
+  if (groupDroppable && closestCenterCollisions.length === 0) {
+    return [groupDroppable];
+  }
+  if (groupDroppable) {
+    var hasNonGroupSortable = closestCenterCollisions.some(function (c) {
+      var _c$data2;
+      var type = (_c$data2 = c.data) === null || _c$data2 === void 0 || (_c$data2 = _c$data2.droppableContainer) === null || _c$data2 === void 0 || (_c$data2 = _c$data2.data) === null || _c$data2 === void 0 || (_c$data2 = _c$data2.current) === null || _c$data2 === void 0 ? void 0 : _c$data2.type;
+      return type !== SORTABLE_LAYER_GROUP_DROPPABLE_TYPE && type !== SORTABLE_LAYER_END_TYPE;
+    });
+    if (!hasNonGroupSortable) {
+      return [groupDroppable];
+    }
+  }
+  return closestCenterCollisions;
+};
+DndContextFactory.deps = [LayerPanelHeaderFactory, LayerGroupHeaderFactory];
+function DndContextFactory(LayerPanelHeader, LayerGroupHeader) {
+  var LayerPanelOverlay = function LayerPanelOverlay(_ref) {
+    var layer = _ref.layer,
+      datasets = _ref.datasets;
+    var color = layer.config.dataId && datasets[layer.config.dataId] ? datasets[layer.config.dataId].color : null;
+    return /*#__PURE__*/React.createElement(LayerPanelHeader, {
+      isConfigActive: false,
+      layerId: layer.id,
+      isVisible: true,
+      isValid: true,
+      label: layer.config.label,
+      labelRCGColorValues: color,
+      onToggleVisibility: nop,
+      onResetIsValid: nop,
+      onUpdateLayerLabel: nop,
+      onToggleEnableConfig: nop,
+      onDuplicateLayer: nop,
+      onRemoveLayer: nop,
+      onZoomToLayer: nop,
+      layerType: layer.type,
+      allowDuplicate: false,
+      isDragNDropEnabled: false
+    });
+  };
+  var DndContext = function DndContext(_ref2) {
+    var children = _ref2.children,
+      visState = _ref2.visState;
+    var datasets = visState.datasets,
+      layerOrder = visState.layerOrder,
+      layers = visState.layers,
+      effects = visState.effects,
+      effectOrder = visState.effectOrder,
+      splitMaps = visState.splitMaps;
+    var _useDndLayers = useDndLayers(layers, layerOrder),
+      activeElement = _useDndLayers.activeElement,
+      onLayerDragStart = _useDndLayers.onDragStart,
+      onLayerDragEnd = _useDndLayers.onDragEnd;
+    var _useDndEffects = useDndEffects(effects, effectOrder),
+      onEffectDragStart = _useDndEffects.onDragStart,
+      onEffectDragEnd = _useDndEffects.onDragEnd;
+    var isSplit = useMemo(function () {
+      return (splitMaps === null || splitMaps === void 0 ? void 0 : splitMaps.length) > 1;
+    }, [splitMaps]);
+    var dndModifiers = useMemo(function () {
+      return isSplit ? DND_EMPTY_MODIFIERS : DND_MODIFIERS;
+    }, [isSplit]);
+    var activeElementType = activeElement === null || activeElement === void 0 ? void 0 : activeElement[0];
+    var activeElementObject = activeElement === null || activeElement === void 0 ? void 0 : activeElement[1];
+    var onDragStart = useCallback(function (event) {
+      var _event$active$data;
+      var activeType = (_event$active$data = event.active.data) === null || _event$active$data === void 0 || (_event$active$data = _event$active$data.current) === null || _event$active$data === void 0 ? void 0 : _event$active$data.type;
+      switch (activeType) {
+        case SORTABLE_LAYER_TYPE:
+        case SORTABLE_LAYER_GROUP_TYPE:
+          onLayerDragStart(event);
+          break;
+        case SORTABLE_EFFECT_TYPE:
+          onEffectDragStart(event);
+          break;
+        default:
+          Console.log("activeType ".concat(activeType, " unknown"));
+      }
+    }, [onLayerDragStart, onEffectDragStart]);
+    var onDragEnd = useCallback(function (event) {
+      var _event$active$data2;
+      var activeType = (_event$active$data2 = event.active.data) === null || _event$active$data2 === void 0 || (_event$active$data2 = _event$active$data2.current) === null || _event$active$data2 === void 0 ? void 0 : _event$active$data2.type;
+      switch (activeType) {
+        case SORTABLE_LAYER_TYPE:
+        case SORTABLE_LAYER_GROUP_TYPE:
+          onLayerDragEnd(event);
+          break;
+        case SORTABLE_EFFECT_TYPE:
+          onEffectDragEnd(event);
+          break;
+        default:
+          Console.log("activeType ".concat(activeType, " unknown"));
+      }
+    }, [onLayerDragEnd, onEffectDragEnd]);
+    return /*#__PURE__*/React.createElement(DndKitContext, {
+      onDragStart: onDragStart,
+      onDragEnd: onDragEnd,
+      modifiers: dndModifiers,
+      collisionDetection: layerGroupCollisionDetection
+    }, children, /*#__PURE__*/React.createElement(DragOverlay, {
+      modifiers: dndModifiers,
+      dropAnimation: null
+    }, activeElementType === 'layer' && activeElementObject ? /*#__PURE__*/React.createElement(DragItem, null, /*#__PURE__*/React.createElement(LayerPanelOverlay, {
+      layer: activeElementObject,
+      datasets: datasets
+    })) : null, activeElementType === 'layerGroup' && activeElementObject ? /*#__PURE__*/React.createElement(DragItem, null, /*#__PURE__*/React.createElement(LayerGroupHeader, {
+      layerGroup: activeElementObject
+    })) : null));
+  };
+  return DndContext;
+}
+export default DndContextFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useMemo","styled","DndContext","DndKitContext","DragOverlay","closestCenter","pointerWithin","Console","LayerPanelHeaderFactory","LayerGroupHeaderFactory","useDndLayers","useDndEffects","DND_MODIFIERS","DND_EMPTY_MODIFIERS","SORTABLE_LAYER_TYPE","SORTABLE_LAYER_GROUP_TYPE","SORTABLE_LAYER_END_TYPE","SORTABLE_EFFECT_TYPE","SORTABLE_LAYER_GROUP_DROPPABLE_TYPE","DragItem","div","_templateObject","_taggedTemplateLiteral","props","theme","textColorHl","radioButtonRadius","nop","undefined","layerGroupCollisionDetection","args","_args$active$data","activeType","active","data","current","type","filteredArgs","_objectSpread","droppableContainers","filter","container","_container$data","_container$data2","parent","closestCenterCollisions","pointerCollisions","groupDroppable","find","c","_c$data","droppableContainer","length","hasNonGroupSortable","some","_c$data2","DndContextFactory","deps","LayerPanelHeader","LayerGroupHeader","LayerPanelOverlay","_ref","layer","datasets","color","config","dataId","createElement","isConfigActive","layerId","id","isVisible","isValid","label","labelRCGColorValues","onToggleVisibility","onResetIsValid","onUpdateLayerLabel","onToggleEnableConfig","onDuplicateLayer","onRemoveLayer","onZoomToLayer","layerType","allowDuplicate","isDragNDropEnabled","_ref2","children","visState","layerOrder","layers","effects","effectOrder","splitMaps","_useDndLayers","activeElement","onLayerDragStart","onDragStart","onLayerDragEnd","onDragEnd","_useDndEffects","onEffectDragStart","onEffectDragEnd","isSplit","dndModifiers","activeElementType","activeElementObject","event","_event$active$data","log","concat","_event$active$data2","modifiers","collisionDetection","dropAnimation","layerGroup"],"sources":["../../src/dnd-context.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useCallback, useMemo, PropsWithChildren} from 'react';\nimport styled from 'styled-components';\nimport {\n  DndContext as DndKitContext,\n  DragOverlay,\n  closestCenter,\n  pointerWithin,\n  CollisionDetection\n} from '@dnd-kit/core';\n\nimport Console from 'global/console';\nimport {VisState} from '@kepler.gl/schemas';\nimport {LayerOrderGroup} from '@kepler.gl/types';\nimport {Layer} from '@kepler.gl/layers';\n\nimport LayerPanelHeaderFactory from './side-panel/layer-panel/layer-panel-header';\nimport LayerGroupHeaderFactory from './side-panel/layer-panel/layer-group-header';\nimport useDndLayers from './hooks/use-dnd-layers';\nimport useDndEffects from './hooks/use-dnd-effects';\n\nimport {\n  DND_MODIFIERS,\n  DND_EMPTY_MODIFIERS,\n  SORTABLE_LAYER_TYPE,\n  SORTABLE_LAYER_GROUP_TYPE,\n  SORTABLE_LAYER_END_TYPE,\n  SORTABLE_EFFECT_TYPE,\n  SORTABLE_LAYER_GROUP_DROPPABLE_TYPE\n} from './common/dnd-layer-items';\n\nexport type DndContextProps = PropsWithChildren<{\n  visState: VisState;\n}>;\n\nexport type DndContextComponent = React.FC<DndContextProps>;\n\nexport const DragItem = styled.div`\n  color: ${props => props.theme.textColorHl};\n  border-radius: ${props => props.theme.radioButtonRadius}px;\n  padding: 5px 10px;\n  display: inline;\n`;\n\nconst nop = () => undefined;\n\n/**\n * Hybrid collision detection: uses closestCenter for sortable items (stable reordering\n * without flickering) and pointerWithin for group droppable containers (reliable drop\n * detection even when group is the last item). When dragging a group, only root-level\n * sortable items are considered to prevent flickering from nested items.\n */\nconst layerGroupCollisionDetection: CollisionDetection = args => {\n  const activeType = args.active.data?.current?.type;\n\n  // When dragging a group, only consider root-level sortable items (no parent)\n  if (activeType === SORTABLE_LAYER_GROUP_TYPE) {\n    const filteredArgs = {\n      ...args,\n      droppableContainers: args.droppableContainers.filter(container => {\n        const type = container.data?.current?.type;\n        return (\n          type === SORTABLE_LAYER_GROUP_TYPE ||\n          type === SORTABLE_LAYER_END_TYPE ||\n          (type === SORTABLE_LAYER_TYPE && !container.data?.current?.parent)\n        );\n      })\n    };\n    return closestCenter(filteredArgs);\n  }\n\n  const closestCenterCollisions = closestCenter(args);\n  const pointerCollisions = pointerWithin(args);\n\n  const groupDroppable = pointerCollisions.find(c => {\n    const type = c.data?.droppableContainer?.data?.current?.type;\n    return type === SORTABLE_LAYER_GROUP_DROPPABLE_TYPE;\n  });\n\n  if (groupDroppable && closestCenterCollisions.length === 0) {\n    return [groupDroppable];\n  }\n\n  if (groupDroppable) {\n    const hasNonGroupSortable = closestCenterCollisions.some(c => {\n      const type = c.data?.droppableContainer?.data?.current?.type;\n      return type !== SORTABLE_LAYER_GROUP_DROPPABLE_TYPE && type !== SORTABLE_LAYER_END_TYPE;\n    });\n    if (!hasNonGroupSortable) {\n      return [groupDroppable];\n    }\n  }\n\n  return closestCenterCollisions;\n};\n\nDndContextFactory.deps = [LayerPanelHeaderFactory, LayerGroupHeaderFactory];\n\nfunction DndContextFactory(\n  LayerPanelHeader: ReturnType<typeof LayerPanelHeaderFactory>,\n  LayerGroupHeader: ReturnType<typeof LayerGroupHeaderFactory>\n): React.FC<DndContextProps> {\n  const LayerPanelOverlay = ({layer, datasets}) => {\n    const color =\n      layer.config.dataId && datasets[layer.config.dataId]\n        ? datasets[layer.config.dataId].color\n        : null;\n    return (\n      <LayerPanelHeader\n        isConfigActive={false}\n        layerId={layer.id}\n        isVisible={true}\n        isValid={true}\n        label={layer.config.label}\n        labelRCGColorValues={color}\n        onToggleVisibility={nop}\n        onResetIsValid={nop}\n        onUpdateLayerLabel={nop}\n        onToggleEnableConfig={nop}\n        onDuplicateLayer={nop}\n        onRemoveLayer={nop}\n        onZoomToLayer={nop}\n        layerType={layer.type}\n        allowDuplicate={false}\n        isDragNDropEnabled={false}\n      />\n    );\n  };\n\n  const DndContext = ({children, visState}: DndContextProps) => {\n    const {datasets, layerOrder, layers, effects, effectOrder, splitMaps} = visState;\n\n    const {\n      activeElement,\n      onDragStart: onLayerDragStart,\n      onDragEnd: onLayerDragEnd\n    } = useDndLayers(layers, layerOrder);\n    const {onDragStart: onEffectDragStart, onDragEnd: onEffectDragEnd} = useDndEffects(\n      effects,\n      effectOrder\n    );\n\n    const isSplit = useMemo(() => splitMaps?.length > 1, [splitMaps]);\n    const dndModifiers = useMemo(() => (isSplit ? DND_EMPTY_MODIFIERS : DND_MODIFIERS), [isSplit]);\n\n    const activeElementType = activeElement?.[0];\n    const activeElementObject = activeElement?.[1];\n\n    const onDragStart = useCallback(\n      event => {\n        const activeType = event.active.data?.current?.type;\n        switch (activeType) {\n          case SORTABLE_LAYER_TYPE:\n          case SORTABLE_LAYER_GROUP_TYPE:\n            onLayerDragStart(event);\n            break;\n          case SORTABLE_EFFECT_TYPE:\n            onEffectDragStart(event);\n            break;\n          default:\n            Console.log(`activeType ${activeType} unknown`);\n        }\n      },\n      [onLayerDragStart, onEffectDragStart]\n    );\n\n    const onDragEnd = useCallback(\n      event => {\n        const activeType = event.active.data?.current?.type;\n        switch (activeType) {\n          case SORTABLE_LAYER_TYPE:\n          case SORTABLE_LAYER_GROUP_TYPE:\n            onLayerDragEnd(event);\n            break;\n          case SORTABLE_EFFECT_TYPE:\n            onEffectDragEnd(event);\n            break;\n          default:\n            Console.log(`activeType ${activeType} unknown`);\n        }\n      },\n      [onLayerDragEnd, onEffectDragEnd]\n    );\n\n    return (\n      <DndKitContext\n        onDragStart={onDragStart}\n        onDragEnd={onDragEnd}\n        modifiers={dndModifiers}\n        collisionDetection={layerGroupCollisionDetection}\n      >\n        {children}\n        <DragOverlay modifiers={dndModifiers} dropAnimation={null}>\n          {activeElementType === 'layer' && activeElementObject ? (\n            <DragItem>\n              <LayerPanelOverlay layer={activeElementObject as Layer} datasets={datasets} />\n            </DragItem>\n          ) : null}\n          {activeElementType === 'layerGroup' && activeElementObject ? (\n            <DragItem>\n              <LayerGroupHeader layerGroup={activeElementObject as LayerOrderGroup} />\n            </DragItem>\n          ) : null}\n        </DragOverlay>\n      </DndKitContext>\n    );\n  };\n\n  return DndContext;\n}\n\nexport default DndContextFactory;\n"],"mappings":"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","ignoreList":[]}