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

package/dist/esm/hooks/use-legend-position.js

@@ -0,0 +1,170 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+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 { useMemo, useRef, useCallback, useEffect } from 'react';
+var MARGIN = {
+  left: 10,
+  top: 10,
+  right: 10,
+  bottom: 30
+};
+var DEFAULT_POSITION = {
+  x: MARGIN.right,
+  y: MARGIN.bottom,
+  anchorX: 'right',
+  anchorY: 'bottom'
+};
+var MIN_CONTENT_HEIGHT = 100;
+var MAP_CONTROL_HEADER_FULL_HEIGHT = 34;
+export function useCalcLegendPosition(_ref) {
+  var legendContentRef = _ref.legendContentRef,
+    isSidePanelShown = _ref.isSidePanelShown,
+    sidePanelWidth = _ref.sidePanelWidth;
+  return useCallback(function () {
+    var _legendContentRef$cur;
+    var root = (_legendContentRef$cur = legendContentRef.current) === null || _legendContentRef$cur === void 0 ? void 0 : _legendContentRef$cur.closest('.kepler-gl');
+    var legendContent = legendContentRef.current;
+    if (!legendContent || !(root instanceof HTMLElement)) {
+      return DEFAULT_POSITION;
+    }
+    var legendRect = legendContent.getBoundingClientRect();
+    var mapRootBounds = root.getBoundingClientRect();
+    var leftSidebarOffset = isSidePanelShown ? sidePanelWidth : 0;
+    var leftOffset = Math.max(MARGIN.left, legendRect.left - mapRootBounds.left - leftSidebarOffset);
+    var rightOffset = Math.max(MARGIN.right, mapRootBounds.right - legendRect.right);
+    var topOffset = Math.max(MARGIN.top, legendRect.top - mapRootBounds.top);
+    var bottomOffset = Math.max(MARGIN.bottom, mapRootBounds.bottom - legendRect.bottom);
+    return _objectSpread(_objectSpread({}, leftOffset < rightOffset ? {
+      x: leftOffset + leftSidebarOffset,
+      anchorX: 'left'
+    } : {
+      x: rightOffset,
+      anchorX: 'right'
+    }), topOffset < bottomOffset ? {
+      y: topOffset,
+      anchorY: 'top'
+    } : {
+      y: bottomOffset,
+      anchorY: 'bottom'
+    });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [isSidePanelShown, sidePanelWidth]);
+}
+
+/**
+ * Returns a function that calculates the anchored position of the map legend
+ * that is being dragged.
+ */
+export default function useLegendPosition(_ref2) {
+  var _settings$position, _settings$contentHeig, _theme$sidePanel;
+  var legendContentRef = _ref2.legendContentRef,
+    isSidePanelShown = _ref2.isSidePanelShown,
+    settings = _ref2.settings,
+    onChangeSettings = _ref2.onChangeSettings,
+    theme = _ref2.theme,
+    mapHeight = _ref2.mapHeight,
+    mapWidth = _ref2.mapWidth;
+  var pos = (_settings$position = settings === null || settings === void 0 ? void 0 : settings.position) !== null && _settings$position !== void 0 ? _settings$position : DEFAULT_POSITION;
+  var contentHeight = (_settings$contentHeig = settings === null || settings === void 0 ? void 0 : settings.contentHeight) !== null && _settings$contentHeig !== void 0 ? _settings$contentHeig : -1;
+  var positionStyles = useMemo(function () {
+    return _defineProperty(_defineProperty({}, pos.anchorX, pos.x), pos.anchorY, pos.y);
+  }, [pos]);
+  var startHeightRef = useRef(0);
+  var sidePanelWidth = ((_theme$sidePanel = theme.sidePanel) === null || _theme$sidePanel === void 0 ? void 0 : _theme$sidePanel.width) || 0;
+
+  // Calculate dynamic max content height based on map root dimensions
+  var maxContentHeight = useMemo(function () {
+    if (!mapHeight) return undefined;
+    // Available height minus margins and header
+    return mapHeight - MARGIN.top - MARGIN.bottom - MAP_CONTROL_HEADER_FULL_HEIGHT;
+  }, [mapHeight]);
+  var calcPosition = useCalcLegendPosition({
+    legendContentRef: legendContentRef,
+    isSidePanelShown: isSidePanelShown,
+    sidePanelWidth: sidePanelWidth
+  });
+  var updatePosition = useCallback(function () {
+    return onChangeSettings({
+      position: calcPosition()
+    });
+  }, [calcPosition, onChangeSettings]);
+  var startResize = useCallback(function () {
+    var _legendContentRef$cur2;
+    var content = (_legendContentRef$cur2 = legendContentRef.current) === null || _legendContentRef$cur2 === void 0 ? void 0 : _legendContentRef$cur2.querySelector('.map-control__panel-content');
+    if (content instanceof HTMLElement) {
+      startHeightRef.current = content.offsetHeight;
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  var resize = useCallback(function (deltaY) {
+    var _legendContentRef$cur3;
+    var root = (_legendContentRef$cur3 = legendContentRef.current) === null || _legendContentRef$cur3 === void 0 ? void 0 : _legendContentRef$cur3.closest('.kepler-gl');
+    var legendContent = legendContentRef.current;
+    if (root instanceof HTMLElement && legendContent) {
+      var mapRootBounds = root.getBoundingClientRect();
+      var legendRect = legendContent.getBoundingClientRect();
+      var remainingHeight = mapRootBounds.bottom - (legendRect.top + MAP_CONTROL_HEADER_FULL_HEIGHT + MARGIN.bottom);
+      // Use maxContentHeight if available, otherwise fall back to viewport-based calculation
+      var maxHeight = maxContentHeight ? Math.min(maxContentHeight, remainingHeight) : remainingHeight;
+      var nextHeight = Math.min(maxHeight, Math.max(MIN_CONTENT_HEIGHT, startHeightRef.current + deltaY));
+      onChangeSettings({
+        contentHeight: nextHeight
+      });
+      if (contentHeight > 0 && pos.anchorY === 'bottom') {
+        onChangeSettings({
+          position: _objectSpread(_objectSpread({}, pos), {}, {
+            y: pos.y - (nextHeight - contentHeight)
+          })
+        });
+      }
+    }
+  },
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  [contentHeight, pos, onChangeSettings, maxContentHeight]);
+
+  // Shift when side panel is shown/hidden
+  var posRef = useRef(pos);
+  posRef.current = pos;
+  useEffect(function () {
+    var currentPos = posRef.current;
+    if (currentPos.anchorX === 'left') {
+      if (isSidePanelShown) {
+        if (currentPos.x <= sidePanelWidth + MARGIN.left) {
+          onChangeSettings({
+            position: _objectSpread(_objectSpread({}, currentPos), {}, {
+              x: sidePanelWidth + MARGIN.left
+            })
+          });
+        }
+      } else {
+        onChangeSettings({
+          position: _objectSpread(_objectSpread({}, currentPos), {}, {
+            x: Math.max(MARGIN.left, currentPos.x - sidePanelWidth)
+          })
+        });
+      }
+    }
+  }, [isSidePanelShown, onChangeSettings, sidePanelWidth]);
+
+  // Clamp contentHeight when map resizes to ensure legend stays within available space
+  useEffect(function () {
+    if (!mapWidth || !mapHeight || !legendContentRef.current) return;
+    if (maxContentHeight && contentHeight > 0 && contentHeight > maxContentHeight) {
+      onChangeSettings({
+        contentHeight: maxContentHeight
+      });
+    }
+  }, [mapWidth, mapHeight, contentHeight, onChangeSettings, maxContentHeight, legendContentRef]);
+  return {
+    positionStyles: positionStyles,
+    updatePosition: updatePosition,
+    contentHeight: contentHeight,
+    maxContentHeight: maxContentHeight,
+    startResize: startResize,
+    resize: resize
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["useMemo","useRef","useCallback","useEffect","MARGIN","left","top","right","bottom","DEFAULT_POSITION","x","y","anchorX","anchorY","MIN_CONTENT_HEIGHT","MAP_CONTROL_HEADER_FULL_HEIGHT","useCalcLegendPosition","_ref","legendContentRef","isSidePanelShown","sidePanelWidth","_legendContentRef$cur","root","current","closest","legendContent","HTMLElement","legendRect","getBoundingClientRect","mapRootBounds","leftSidebarOffset","leftOffset","Math","max","rightOffset","topOffset","bottomOffset","_objectSpread","useLegendPosition","_ref2","_settings$position","_settings$contentHeig","_theme$sidePanel","settings","onChangeSettings","theme","mapHeight","mapWidth","pos","position","contentHeight","positionStyles","_defineProperty","startHeightRef","sidePanel","width","maxContentHeight","undefined","calcPosition","updatePosition","startResize","_legendContentRef$cur2","content","querySelector","offsetHeight","resize","deltaY","_legendContentRef$cur3","remainingHeight","maxHeight","min","nextHeight","posRef","currentPos"],"sources":["../../../src/hooks/use-legend-position.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {useMemo, useRef, useCallback, useEffect} from 'react';\n\nimport {MapLegendControlSettings} from '@kepler.gl/types';\n\ntype Params = {\n  legendContentRef: React.MutableRefObject<HTMLElement | null>;\n  isSidePanelShown: boolean;\n  settings?: MapLegendControlSettings;\n  onChangeSettings: (settings: Partial<MapLegendControlSettings>) => void;\n  theme: Record<string, any>;\n  mapHeight?: number;\n  mapWidth?: number;\n};\n\ntype ReturnType = {\n  positionStyles: Record<string, unknown>;\n  updatePosition: () => void;\n  contentHeight: number;\n  maxContentHeight?: number;\n  startResize: () => void;\n  resize: (deltaY: number) => void;\n};\n\nconst MARGIN = {\n  left: 10,\n  top: 10,\n  right: 10,\n  bottom: 30\n};\nconst DEFAULT_POSITION: MapLegendControlSettings['position'] = {\n  x: MARGIN.right,\n  y: MARGIN.bottom,\n  anchorX: 'right',\n  anchorY: 'bottom'\n};\nconst MIN_CONTENT_HEIGHT = 100;\nconst MAP_CONTROL_HEADER_FULL_HEIGHT = 34;\n\nexport type UseCalcLegendPositionProps = {\n  legendContentRef: React.MutableRefObject<HTMLElement | null>;\n  isSidePanelShown: boolean;\n  sidePanelWidth: number;\n};\n\nexport function useCalcLegendPosition({\n  legendContentRef,\n  isSidePanelShown,\n  sidePanelWidth\n}: UseCalcLegendPositionProps) {\n  return useCallback((): MapLegendControlSettings['position'] => {\n    const root = legendContentRef.current?.closest('.kepler-gl');\n    const legendContent = legendContentRef.current;\n    if (!legendContent || !(root instanceof HTMLElement)) {\n      return DEFAULT_POSITION;\n    }\n    const legendRect = legendContent.getBoundingClientRect();\n    const mapRootBounds = root.getBoundingClientRect();\n    const leftSidebarOffset = isSidePanelShown ? sidePanelWidth : 0;\n\n    const leftOffset = Math.max(\n      MARGIN.left,\n      legendRect.left - mapRootBounds.left - leftSidebarOffset\n    );\n    const rightOffset = Math.max(MARGIN.right, mapRootBounds.right - legendRect.right);\n\n    const topOffset = Math.max(MARGIN.top, legendRect.top - mapRootBounds.top);\n    const bottomOffset = Math.max(MARGIN.bottom, mapRootBounds.bottom - legendRect.bottom);\n\n    return {\n      ...(leftOffset < rightOffset\n        ? {x: leftOffset + leftSidebarOffset, anchorX: 'left'}\n        : {x: rightOffset, anchorX: 'right'}),\n      ...(topOffset < bottomOffset\n        ? {y: topOffset, anchorY: 'top'}\n        : {y: bottomOffset, anchorY: 'bottom'})\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [isSidePanelShown, sidePanelWidth]);\n}\n\n/**\n * Returns a function that calculates the anchored position of the map legend\n * that is being dragged.\n */\nexport default function useLegendPosition({\n  legendContentRef,\n  isSidePanelShown,\n  settings,\n  onChangeSettings,\n  theme,\n  mapHeight,\n  mapWidth\n}: Params): ReturnType {\n  const pos = settings?.position ?? DEFAULT_POSITION;\n  const contentHeight = settings?.contentHeight ?? -1;\n  const positionStyles = useMemo(() => ({[pos.anchorX]: pos.x, [pos.anchorY]: pos.y}), [pos]);\n  const startHeightRef = useRef(0);\n  const sidePanelWidth = theme.sidePanel?.width || 0;\n\n  // Calculate dynamic max content height based on map root dimensions\n  const maxContentHeight = useMemo(() => {\n    if (!mapHeight) return undefined;\n    // Available height minus margins and header\n    return mapHeight - MARGIN.top - MARGIN.bottom - MAP_CONTROL_HEADER_FULL_HEIGHT;\n  }, [mapHeight]);\n\n  const calcPosition = useCalcLegendPosition({\n    legendContentRef,\n    isSidePanelShown,\n    sidePanelWidth\n  });\n  const updatePosition = useCallback(\n    () => onChangeSettings({position: calcPosition()}),\n    [calcPosition, onChangeSettings]\n  );\n\n  const startResize = useCallback(() => {\n    const content = legendContentRef.current?.querySelector('.map-control__panel-content');\n    if (content instanceof HTMLElement) {\n      startHeightRef.current = content.offsetHeight;\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n  const resize = useCallback(\n    deltaY => {\n      const root = legendContentRef.current?.closest('.kepler-gl');\n      const legendContent = legendContentRef.current;\n      if (root instanceof HTMLElement && legendContent) {\n        const mapRootBounds = root.getBoundingClientRect();\n        const legendRect = legendContent.getBoundingClientRect();\n        const remainingHeight =\n          mapRootBounds.bottom - (legendRect.top + MAP_CONTROL_HEADER_FULL_HEIGHT + MARGIN.bottom);\n        // Use maxContentHeight if available, otherwise fall back to viewport-based calculation\n        const maxHeight = maxContentHeight\n          ? Math.min(maxContentHeight, remainingHeight)\n          : remainingHeight;\n        const nextHeight = Math.min(\n          maxHeight,\n          Math.max(MIN_CONTENT_HEIGHT, startHeightRef.current + deltaY)\n        );\n        onChangeSettings({contentHeight: nextHeight});\n        if (contentHeight > 0 && pos.anchorY === 'bottom') {\n          onChangeSettings({position: {...pos, y: pos.y - (nextHeight - contentHeight)}});\n        }\n      }\n    },\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [contentHeight, pos, onChangeSettings, maxContentHeight]\n  );\n\n  // Shift when side panel is shown/hidden\n  const posRef = useRef(pos);\n  posRef.current = pos;\n  useEffect(() => {\n    const currentPos = posRef.current;\n    if (currentPos.anchorX === 'left') {\n      if (isSidePanelShown) {\n        if (currentPos.x <= sidePanelWidth + MARGIN.left) {\n          onChangeSettings({position: {...currentPos, x: sidePanelWidth + MARGIN.left}});\n        }\n      } else {\n        onChangeSettings({\n          position: {...currentPos, x: Math.max(MARGIN.left, currentPos.x - sidePanelWidth)}\n        });\n      }\n    }\n  }, [isSidePanelShown, onChangeSettings, sidePanelWidth]);\n\n  // Clamp contentHeight when map resizes to ensure legend stays within available space\n  useEffect(() => {\n    if (!mapWidth || !mapHeight || !legendContentRef.current) return;\n    if (maxContentHeight && contentHeight > 0 && contentHeight > maxContentHeight) {\n      onChangeSettings({contentHeight: maxContentHeight});\n    }\n  }, [mapWidth, mapHeight, contentHeight, onChangeSettings, maxContentHeight, legendContentRef]);\n\n  return {positionStyles, updatePosition, contentHeight, maxContentHeight, startResize, resize};\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/hooks/use-on-click-outside.js

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import document from 'global/document';
+import { useCallback, useEffect, useRef } from 'react';
+export default function useOnClickOutside(onClose) {
+  var disabled = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  var containerRef = useRef(null);
+  var handleClickOutside = useCallback(function (e) {
+    if (containerRef.current && !containerRef.current.contains(e.target)) {
+      onClose(e);
+    }
+  }, [onClose]);
+  useEffect(function () {
+    if (disabled) {
+      return;
+    }
+    document.addEventListener('click', handleClickOutside, {
+      capture: true
+    });
+    return function () {
+      document.removeEventListener('click', handleClickOutside, {
+        capture: true
+      });
+    };
+  }, [handleClickOutside, disabled]);
+  return containerRef;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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