@kepler.gl/components 3.1.0-alpha.1 → 3.1.0-alpha.2

package/dist/map-view-state-context.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { MapViewState } from '@deck.gl/core/typed';
+import { MapState } from '@kepler.gl/types';
+export declare type MapViewStateContextType = {
+    getInternalViewState: (index?: number) => MapViewState;
+    setInternalViewState: (viewState?: MapViewState, index?: number) => void;
+};
+export declare const MapViewStateContext: React.Context<MapViewStateContextType>;
+/**
+ * This context provider is used to localize the map view state so
+ * that changes to the map view state do not affect the rest of the app,
+ * mainly to prevent issues we experienced with basemap/deck viewport syncing.
+ */
+export declare const MapViewStateContextProvider: ({ mapState, children }: {
+    mapState: MapState;
+    children: React.ReactNode;
+}) => React.JSX.Element;

package/dist/map-view-state-context.js

@@ -0,0 +1,99 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MapViewStateContextProvider = exports.MapViewStateContext = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = _interopRequireWildcard(require("react"));
+var _lodash = _interopRequireDefault(require("lodash.isequal"));
+var _lodash2 = _interopRequireDefault(require("lodash.pick"));
+var _reducers = require("@kepler.gl/reducers");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+var MapViewStateContext = exports.MapViewStateContext = /*#__PURE__*/(0, _react.createContext)({
+  getInternalViewState: function getInternalViewState() {
+    return {
+      latitude: 0,
+      longitude: 0,
+      zoom: 0
+    };
+  },
+  setInternalViewState: function setInternalViewState() {
+    return;
+  }
+});
+
+/**
+ * This context provider is used to localize the map view state so
+ * that changes to the map view state do not affect the rest of the app,
+ * mainly to prevent issues we experienced with basemap/deck viewport syncing.
+ */
+
+var MapViewStateContextProvider = exports.MapViewStateContextProvider = function MapViewStateContextProvider(_ref) {
+  var mapState = _ref.mapState,
+    children = _ref.children;
+  var _ref2 = mapState || {},
+    isSplit = _ref2.isSplit,
+    isViewportSynced = _ref2.isViewportSynced;
+
+  // Store locally map view states by mapIndex
+  var _useState = (0, _react.useState)([mapState]),
+    _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+    viewStates = _useState2[0],
+    setViewStates = _useState2[1];
+
+  // Detect and apply outside viewport changes
+  // (e.g. from geocoder or when switching to 3d mode)
+  (0, _react.useEffect)(function () {
+    if (!mapState) return;
+    var primaryState = viewStates[0];
+    if (primaryState === mapState) return;
+    var props = Object.keys(primaryState).filter(function (key) {
+      return !key.startsWith('transition');
+    });
+    var hasChanged = function hasChanged(a, b) {
+      return !(0, _lodash["default"])((0, _lodash2["default"])(a, props), (0, _lodash2["default"])(b, props));
+    };
+    if (isSplit && !isViewportSynced) {
+      var _mapState$splitMapVie;
+      if ((_mapState$splitMapVie = mapState.splitMapViewports) !== null && _mapState$splitMapVie !== void 0 && _mapState$splitMapVie.some(function (s, i) {
+        return hasChanged(s, viewStates[i]);
+      })) {
+        setViewStates(mapState.splitMapViewports);
+      }
+    } else if (hasChanged(primaryState, mapState)) {
+      setViewStates([(0, _reducers.pickViewportPropsFromMapState)(mapState)]);
+    }
+    // Only update internalViewState when viewState changes
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [mapState]);
+  var value = {
+    getInternalViewState: function getInternalViewState() {
+      var _viewStates$index;
+      var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+      return (_viewStates$index = viewStates[index]) !== null && _viewStates$index !== void 0 ? _viewStates$index : viewStates[0];
+    },
+    setInternalViewState: function setInternalViewState(newViewState) {
+      var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      setViewStates(function (prevViewStates) {
+        if (isSplit && !isViewportSynced) {
+          var nextViewStates = (0, _toConsumableArray2["default"])(prevViewStates);
+          nextViewStates[index] = newViewState;
+          return nextViewStates;
+        }
+        return [newViewState];
+      });
+    }
+  };
+  return /*#__PURE__*/_react["default"].createElement(MapViewStateContext.Provider, {
+    value: value
+  }, children);
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","_lodash","_interopRequireDefault","_lodash2","_reducers","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","_typeof","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","MapViewStateContext","exports","createContext","getInternalViewState","latitude","longitude","zoom","setInternalViewState","MapViewStateContextProvider","_ref","mapState","children","_ref2","isSplit","isViewportSynced","_useState","useState","_useState2","_slicedToArray2","viewStates","setViewStates","useEffect","primaryState","props","keys","filter","key","startsWith","hasChanged","b","isEqual","pick","_mapState$splitMapVie","splitMapViewports","some","s","pickViewportPropsFromMapState","value","_viewStates$index","index","arguments","length","undefined","newViewState","prevViewStates","nextViewStates","_toConsumableArray2","createElement","Provider"],"sources":["../src/map-view-state-context.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useState, useEffect, createContext} from 'react';\nimport isEqual from 'lodash.isequal';\nimport pick from 'lodash.pick';\nimport {MapViewState} from '@deck.gl/core/typed';\nimport {pickViewportPropsFromMapState} from '@kepler.gl/reducers';\n\nimport {MapState} from '@kepler.gl/types';\n\nexport type MapViewStateContextType = {\n  getInternalViewState: (index?: number) => MapViewState;\n  setInternalViewState: (viewState?: MapViewState, index?: number) => void;\n};\n\nexport const MapViewStateContext: React.Context<MapViewStateContextType> = createContext({\n  getInternalViewState: () => ({latitude: 0, longitude: 0, zoom: 0}),\n  setInternalViewState: () => {\n    return;\n  }\n});\n\n/**\n * This context provider is used to localize the map view state so\n * that changes to the map view state do not affect the rest of the app,\n * mainly to prevent issues we experienced with basemap/deck viewport syncing.\n */\n\nexport const MapViewStateContextProvider = ({\n  mapState,\n  children\n}: {\n  mapState: MapState;\n  children: React.ReactNode;\n}) => {\n  const {isSplit, isViewportSynced} = mapState || {};\n\n  // Store locally map view states by mapIndex\n  const [viewStates, setViewStates] = useState([mapState]);\n\n  // Detect and apply outside viewport changes\n  // (e.g. from geocoder or when switching to 3d mode)\n  useEffect(() => {\n    if (!mapState) return;\n    const primaryState = viewStates[0];\n    if (primaryState === mapState) return;\n    const props = Object.keys(primaryState).filter(key => !key.startsWith('transition'));\n    const hasChanged = (a, b) => !isEqual(pick(a, props), pick(b, props));\n    if (isSplit && !isViewportSynced) {\n      if (mapState.splitMapViewports?.some((s, i) => hasChanged(s, viewStates[i]))) {\n        setViewStates(mapState.splitMapViewports as MapState[]);\n      }\n    } else if (hasChanged(primaryState, mapState)) {\n      setViewStates([pickViewportPropsFromMapState(mapState)] as MapState[]);\n    }\n    // Only update internalViewState when viewState changes\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [mapState]);\n\n  const value = {\n    getInternalViewState: (index = 0) => viewStates[index] ?? viewStates[0],\n    setInternalViewState: (newViewState, index = 0) => {\n      setViewStates(prevViewStates => {\n        if (isSplit && !isViewportSynced) {\n          const nextViewStates = [...prevViewStates];\n          nextViewStates[index] = newViewState as MapState;\n          return nextViewStates;\n        }\n        return [newViewState] as MapState[];\n      });\n    }\n  } as MapViewStateContextType;\n  return <MapViewStateContext.Provider value={value}>{children}</MapViewStateContext.Provider>;\n};\n"],"mappings":"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","ignoreList":[]}

package/dist/maps-layout.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { MapState } from '@kepler.gl/types';
+interface MapsLayoutProps {
+    mapState: MapState;
+    className?: string;
+    children?: React.ReactNode;
+}
+declare function MapsLayoutFactory(): React.ComponentType<MapsLayoutProps>;
+declare namespace MapsLayoutFactory {
+    var deps: any[];
+}
+export default MapsLayoutFactory;

package/dist/maps-layout.js

@@ -0,0 +1,43 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = MapsLayoutFactory;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+var _react = _interopRequireDefault(require("react"));
+var _mapViewStateContext = require("./map-view-state-context");
+var _templateObject; // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+var Outer = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  position: relative;\n  display: flex;\n  width: 100%;\n  height: 100%;\n"])));
+MapsLayoutFactory.deps = [];
+function MapsLayoutFactory() {
+  var MapsLayout = /*#__PURE__*/function (_React$Component) {
+    function MapsLayout() {
+      (0, _classCallCheck2["default"])(this, MapsLayout);
+      return _callSuper(this, MapsLayout, arguments);
+    }
+    (0, _inherits2["default"])(MapsLayout, _React$Component);
+    return (0, _createClass2["default"])(MapsLayout, [{
+      key: "render",
+      value: function render() {
+        return /*#__PURE__*/_react["default"].createElement(Outer, {
+          className: this.props.className
+        }, /*#__PURE__*/_react["default"].createElement(_mapViewStateContext.MapViewStateContextProvider, {
+          mapState: this.props.mapState
+        }, this.props.children));
+      }
+    }]);
+  }(_react["default"].Component);
+  return MapsLayout;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/modal-container.d.ts

@@ -0,0 +1,59 @@
+import React from 'react';
+import { MapStyle, ProviderState } from '@kepler.gl/reducers';
+import ModalDialogFactory from './modals/modal-dialog';
+import DeleteDatasetModalFactory from './modals/delete-data-modal';
+import OverWriteMapModalFactory from './modals/overwrite-map-modal';
+import DataTableModalFactory from './modals/data-table-modal';
+import LoadDataModalFactory from './modals/load-data-modal';
+import ExportImageModalFactory from './modals/export-image-modal';
+import ExportDataModalFactory from './modals/export-data-modal';
+import ExportMapModalFactory from './modals/export-map-modal/export-map-modal';
+import AddMapStyleModalFactory from './modals/add-map-style-modal';
+import SaveMapModalFactory from './modals/save-map-modal';
+import ShareMapModalFactory from './modals/share-map-modal';
+import { MapState, UiState, OnSuccessCallBack, OnErrorCallBack } from '@kepler.gl/types';
+import { VisStateActions, UIStateActions, MapStyleActions, ProviderActions } from '@kepler.gl/actions';
+import { Provider } from '@kepler.gl/cloud-providers';
+import { VisState } from '@kepler.gl/schemas';
+export declare type ModalContainerProps = {
+    appName: string;
+    rootNode: React.ReactInstance | null | undefined;
+    containerW: number;
+    containerH: number;
+    mapboxApiAccessToken: string;
+    mapboxApiUrl?: string;
+    mapState: MapState;
+    mapStyle: MapStyle;
+    uiState: UiState;
+    visState: VisState;
+    providerState: ProviderState;
+    visStateActions: typeof VisStateActions;
+    uiStateActions: typeof UIStateActions;
+    mapStyleActions: typeof MapStyleActions;
+    providerActions: typeof ProviderActions;
+    onSaveToStorage?: () => void;
+    cloudProviders: Provider[];
+    onLoadCloudMapSuccess?: OnSuccessCallBack;
+    onLoadCloudMapError?: OnErrorCallBack;
+    onExportToCloudSuccess?: OnSuccessCallBack;
+    onExportToCloudError?: OnErrorCallBack;
+};
+declare function ModalContainerFactory(DeleteDatasetModal: ReturnType<typeof DeleteDatasetModalFactory>, OverWriteMapModal: ReturnType<typeof OverWriteMapModalFactory>, DataTableModal: ReturnType<typeof DataTableModalFactory>, LoadDataModal: ReturnType<typeof LoadDataModalFactory>, ExportImageModal: ReturnType<typeof ExportImageModalFactory>, ExportDataModal: ReturnType<typeof ExportDataModalFactory>, ExportMapModal: ReturnType<typeof ExportMapModalFactory>, AddMapStyleModal: ReturnType<typeof AddMapStyleModalFactory>, ModalDialog: ReturnType<typeof ModalDialogFactory>, SaveMapModal: ReturnType<typeof SaveMapModalFactory>, ShareMapModal: ReturnType<typeof ShareMapModalFactory>): React.ElementType<ModalContainerProps>;
+declare namespace ModalContainerFactory {
+    var deps: (typeof ShareMapModalFactory | (() => React.FC<import("./modals/delete-data-modal").DeleteDatasetModalProps>) | (() => React.FC<{
+        mapSaved: string | null;
+        title: string;
+        isProviderLoading: boolean;
+        onUpdateImageSetting: (newSetting: Partial<import("@kepler.gl/constants").ExportImage>) => void;
+        cleanupExportImage: () => {
+            type: "@@kepler.gl/CLEANUP_EXPORT_IMAGE";
+        };
+        onConfirm: (provider: Provider) => void;
+        onCancel: () => void;
+    }>) | typeof DataTableModalFactory | typeof LoadDataModalFactory | (() => React.FC<import("react-intl").WithIntlProps<import("./modals/export-image-modal").ExportImageModalProps>> & {
+        WrappedComponent: React.ComponentType<import("./modals/export-image-modal").ExportImageModalProps>;
+    }) | (() => React.FC<import("react-intl").WithIntlProps<import("./modals/export-data-modal").ExportDataModalProps>> & {
+        WrappedComponent: React.ComponentType<import("./modals/export-data-modal").ExportDataModalProps>;
+    }) | typeof ExportMapModalFactory | typeof AddMapStyleModalFactory | (() => import("styled-components").StyledComponent<typeof import("./common/modal").ModalDialog, any, {}, never>) | typeof SaveMapModalFactory)[];
+}
+export default ModalContainerFactory;