@kepler.gl/components 3.3.0-alpha.5 → 3.3.0-alpha.6

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

@@ -0,0 +1,89 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useState, useEffect, createContext } from 'react';
+import isEqual from 'lodash/isEqual';
+import pick from 'lodash/pick';
+import { pickViewportPropsFromMapState } from '@kepler.gl/reducers';
+export var MapViewStateContext = /*#__PURE__*/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.
+ */
+
+export var 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 = useState([mapState]),
+    _useState2 = _slicedToArray(_useState, 2),
+    viewStates = _useState2[0],
+    setViewStates = _useState2[1];
+
+  // Detect and apply outside viewport changes
+  // (e.g. from geocoder or when switching to 3d mode)
+  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 !isEqual(pick(a, props), pick(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([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 = _toConsumableArray(prevViewStates);
+          nextViewStates[index] = newViewState;
+          return nextViewStates;
+        }
+        return [newViewState];
+      });
+    }
+  };
+  return /*#__PURE__*/React.createElement(MapViewStateContext.Provider, {
+    value: value
+  }, children);
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useState","useEffect","createContext","isEqual","pick","pickViewportPropsFromMapState","MapViewStateContext","getInternalViewState","latitude","longitude","zoom","setInternalViewState","MapViewStateContextProvider","_ref","mapState","children","_ref2","isSplit","isViewportSynced","_useState","_useState2","_slicedToArray","viewStates","setViewStates","primaryState","props","Object","keys","filter","key","startsWith","hasChanged","a","b","_mapState$splitMapVie","splitMapViewports","some","s","i","value","_viewStates$index","index","arguments","length","undefined","newViewState","prevViewStates","nextViewStates","_toConsumableArray","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';\ntype MapViewState = {\n  latitude: number;\n  longitude: number;\n  zoom: number;\n  bearing?: number;\n  pitch?: number;\n  maxPitch?: number;\n  minZoom?: number;\n  maxZoom?: number;\n};\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/esm/maps-layout.js

@@ -0,0 +1,95 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import styled from 'styled-components';
+import React, { useRef, useState, useCallback, useEffect } from 'react';
+import { MapSplitMode } from '@kepler.gl/constants';
+import { MapViewStateContextProvider } from './map-view-state-context';
+import LayoutSplitter, { LayoutSplitterMode } from './common/layout-splitter';
+var Outer = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  position: relative;\n  display: flex;\n  width: 100%;\n  height: 100%;\n"])));
+var MapWrapper = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  position: ", ";\n  top: 0;\n  left: 0;\n  width: 100%;\n  height: 100%;\n  z-index: 0;\n"])), function (props) {
+  return props.$relative ? 'relative' : 'absolute';
+});
+var SwipeInputBlock = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  position: absolute;\n  top: 0;\n  left: 0;\n  width: 100%;\n  height: 100%;\n  background: transparent;\n  z-index: 2;\n"])));
+MapsLayoutFactory.deps = [];
+export default function MapsLayoutFactory() {
+  var MapsLayout = function MapsLayout(_ref) {
+    var _mapState$swipeCompar;
+    var mapState = _ref.mapState,
+      className = _ref.className,
+      children = _ref.children,
+      onSetSwipeComparePercentage = _ref.onSetSwipeComparePercentage;
+    var containerElementRef = useRef(null);
+    var _useState = useState(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      containerMounted = _useState2[0],
+      setContainerMounted = _useState2[1];
+    var childrenArray = React.Children.toArray(children);
+    var isSwipe = childrenArray.length > 1 && mapState.mapSplitMode === MapSplitMode.SWIPE_COMPARE;
+    var percentage = (_mapState$swipeCompar = mapState.swipeComparePercentage) !== null && _mapState$swipeCompar !== void 0 ? _mapState$swipeCompar : 50;
+    var _useState3 = useState(percentage),
+      _useState4 = _slicedToArray(_useState3, 2),
+      internalPercentage = _useState4[0],
+      setInternalPercentage = _useState4[1];
+    var _useState5 = useState(false),
+      _useState6 = _slicedToArray(_useState5, 2),
+      isSwiping = _useState6[0],
+      setSwiping = _useState6[1];
+    var lastReleasedValue = useRef(null);
+    useEffect(function () {
+      if (containerElementRef.current) {
+        setContainerMounted(true);
+      }
+    }, []);
+    useEffect(function () {
+      if (!isSwiping) {
+        // Only sync from props if the store has caught up with our last released value,
+        // or if we never released (external prop change).
+        if (lastReleasedValue.current === null || percentage === lastReleasedValue.current) {
+          setInternalPercentage(percentage);
+          lastReleasedValue.current = null;
+        }
+      }
+    }, [percentage, isSwiping]);
+    var handleMove = useCallback(function (v) {
+      setSwiping(true);
+      setInternalPercentage(v);
+    }, []);
+    var handleRelease = useCallback(function (v) {
+      lastReleasedValue.current = v;
+      setInternalPercentage(v);
+      setSwiping(false);
+      if (v !== percentage && onSetSwipeComparePercentage) {
+        onSetSwipeComparePercentage({
+          percentage: v
+        });
+      }
+    }, [percentage, onSetSwipeComparePercentage]);
+    var splitMapStyle = {
+      clipPath: "polygon(0 0, 0 100%, ".concat(internalPercentage, "% 100%, ").concat(internalPercentage, "% 0)"),
+      overflow: 'hidden'
+    };
+    return /*#__PURE__*/React.createElement(Outer, {
+      className: className,
+      ref: containerElementRef
+    }, /*#__PURE__*/React.createElement(MapViewStateContextProvider, {
+      mapState: mapState
+    }, isSwipe ? /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(MapWrapper, {
+      key: 1
+    }, childrenArray[1]), /*#__PURE__*/React.createElement(MapWrapper, {
+      key: 0,
+      style: splitMapStyle
+    }, childrenArray[0]), containerMounted && containerElementRef.current && /*#__PURE__*/React.createElement(React.Fragment, null, isSwiping && /*#__PURE__*/React.createElement(SwipeInputBlock, null), /*#__PURE__*/React.createElement(LayoutSplitter, {
+      mode: LayoutSplitterMode.VERTICAL,
+      referenceElement: containerElementRef.current,
+      percentageSplit: internalPercentage,
+      onMove: handleMove,
+      onRelease: handleRelease
+    }))) : childrenArray));
+  };
+  return MapsLayout;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["styled","React","useRef","useState","useCallback","useEffect","MapSplitMode","MapViewStateContextProvider","LayoutSplitter","LayoutSplitterMode","Outer","div","_templateObject","_taggedTemplateLiteral","MapWrapper","_templateObject2","props","$relative","SwipeInputBlock","_templateObject3","MapsLayoutFactory","deps","MapsLayout","_ref","_mapState$swipeCompar","mapState","className","children","onSetSwipeComparePercentage","containerElementRef","_useState","_useState2","_slicedToArray","containerMounted","setContainerMounted","childrenArray","Children","toArray","isSwipe","length","mapSplitMode","SWIPE_COMPARE","percentage","swipeComparePercentage","_useState3","_useState4","internalPercentage","setInternalPercentage","_useState5","_useState6","isSwiping","setSwiping","lastReleasedValue","current","handleMove","v","handleRelease","splitMapStyle","clipPath","concat","overflow","createElement","ref","Fragment","key","style","mode","VERTICAL","referenceElement","percentageSplit","onMove","onRelease"],"sources":["../../src/maps-layout.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport styled from 'styled-components';\nimport React, {useRef, useState, useCallback, useEffect} from 'react';\n\nimport {MapState} from '@kepler.gl/types';\nimport {MapSplitMode} from '@kepler.gl/constants';\n\nimport {MapViewStateContextProvider} from './map-view-state-context';\nimport LayoutSplitter, {LayoutSplitterMode} from './common/layout-splitter';\n\nconst Outer = styled.div`\n  position: relative;\n  display: flex;\n  width: 100%;\n  height: 100%;\n`;\n\ntype MapWrapperProps = {\n  $relative?: boolean;\n};\n\nconst MapWrapper = styled.div<MapWrapperProps>`\n  position: ${props => (props.$relative ? 'relative' : 'absolute')};\n  top: 0;\n  left: 0;\n  width: 100%;\n  height: 100%;\n  z-index: 0;\n`;\n\nconst SwipeInputBlock = styled.div`\n  position: absolute;\n  top: 0;\n  left: 0;\n  width: 100%;\n  height: 100%;\n  background: transparent;\n  z-index: 2;\n`;\n\nMapsLayoutFactory.deps = [];\n\ninterface MapsLayoutProps {\n  mapState: MapState;\n  className?: string;\n  children?: React.ReactNode;\n  onSetSwipeComparePercentage?: (payload: {percentage: number}) => void;\n}\n\nexport default function MapsLayoutFactory(): React.ComponentType<MapsLayoutProps> {\n  const MapsLayout: React.FC<MapsLayoutProps> = ({\n    mapState,\n    className,\n    children,\n    onSetSwipeComparePercentage\n  }) => {\n    const containerElementRef = useRef<HTMLDivElement>(null);\n    const [containerMounted, setContainerMounted] = useState(false);\n    const childrenArray = React.Children.toArray(children);\n    const isSwipe =\n      childrenArray.length > 1 && mapState.mapSplitMode === MapSplitMode.SWIPE_COMPARE;\n\n    const percentage = mapState.swipeComparePercentage ?? 50;\n    const [internalPercentage, setInternalPercentage] = useState(percentage);\n    const [isSwiping, setSwiping] = useState(false);\n    const lastReleasedValue = useRef<number | null>(null);\n\n    useEffect(() => {\n      if (containerElementRef.current) {\n        setContainerMounted(true);\n      }\n    }, []);\n\n    useEffect(() => {\n      if (!isSwiping) {\n        // Only sync from props if the store has caught up with our last released value,\n        // or if we never released (external prop change).\n        if (lastReleasedValue.current === null || percentage === lastReleasedValue.current) {\n          setInternalPercentage(percentage);\n          lastReleasedValue.current = null;\n        }\n      }\n    }, [percentage, isSwiping]);\n\n    const handleMove = useCallback((v: number) => {\n      setSwiping(true);\n      setInternalPercentage(v);\n    }, []);\n\n    const handleRelease = useCallback(\n      (v: number) => {\n        lastReleasedValue.current = v;\n        setInternalPercentage(v);\n        setSwiping(false);\n        if (v !== percentage && onSetSwipeComparePercentage) {\n          onSetSwipeComparePercentage({percentage: v});\n        }\n      },\n      [percentage, onSetSwipeComparePercentage]\n    );\n\n    const splitMapStyle = {\n      clipPath: `polygon(0 0, 0 100%, ${internalPercentage}% 100%, ${internalPercentage}% 0)`,\n      overflow: 'hidden' as const\n    };\n\n    return (\n      <Outer className={className} ref={containerElementRef}>\n        <MapViewStateContextProvider mapState={mapState}>\n          {isSwipe ? (\n            <>\n              <MapWrapper key={1}>{childrenArray[1]}</MapWrapper>\n              <MapWrapper key={0} style={splitMapStyle}>\n                {childrenArray[0]}\n              </MapWrapper>\n              {containerMounted && containerElementRef.current && (\n                <>\n                  {isSwiping && <SwipeInputBlock />}\n                  <LayoutSplitter\n                    mode={LayoutSplitterMode.VERTICAL}\n                    referenceElement={containerElementRef.current}\n                    percentageSplit={internalPercentage}\n                    onMove={handleMove}\n                    onRelease={handleRelease}\n                  />\n                </>\n              )}\n            </>\n          ) : (\n            childrenArray\n          )}\n        </MapViewStateContextProvider>\n      </Outer>\n    );\n  };\n\n  return MapsLayout;\n}\n"],"mappings":"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","ignoreList":[]}