@dynatrace/strato-geo 3.6.0 → 3.7.0

package/map/hooks/use-hover-interaction.js

@@ -24,9 +24,16 @@ module.exports = __toCommonJS(use_hover_interaction_exports);
 var import_react_maplibre = require("@vis.gl/react-maplibre");
 var import_lodash_es = require("lodash");
 var import_react = require("react");
-var import_constants = require("../constants.js");
 var import_associated_features = require("../utils/associated-features.js");
 var import_get_min_value_feature = require("../utils/get-min-value-feature.js");
+const MOUSEMOVE_THROTTLE_MS = 16;
+const blurTrackedFeature = (map, featureIdRef, sourceIdRef) => {
+  if (!(0, import_lodash_es.isNil)(featureIdRef.current) && !(0, import_lodash_es.isNil)(sourceIdRef.current)) {
+    blurFeature(map, sourceIdRef.current, featureIdRef.current);
+    featureIdRef.current = void 0;
+    sourceIdRef.current = void 0;
+  }
+};
 const featureExists = (map, source, id) => {
   const isSourcePresent = map.getSource(source) !== void 0;
   return isSourcePresent && map.getFeatureState({
@@ -68,53 +75,59 @@ const hoverFeature = (map, source, id) => {
     }
   }
 };
-const useHoverInteraction = () => {
+const useHoverInteraction = (interactiveLayerIds) => {
   const map = (0, import_react_maplibre.useMap)().current;
-  let featureId;
-  let sourceId;
-  const handleMouseOut = (0, import_react.useCallback)(
-    ({ point }) => {
-      if (!(0, import_lodash_es.isNil)(map) && !(0, import_lodash_es.isUndefined)(featureId) && !(0, import_lodash_es.isUndefined)(sourceId)) {
-        blurFeature(map, sourceId, featureId);
-      }
-    },
-    [featureId, sourceId, map]
-  );
-  const handleMouseMove = (0, import_react.useCallback)(
-    ({ point }) => {
-      if (!(0, import_lodash_es.isNil)(map)) {
-        const features = map.queryRenderedFeatures(point).filter((feature) => !(0, import_associated_features.isAssociatedFeature)(feature.properties.id));
-        map.getCanvas().style.cursor = "grab";
+  const featureIdRef = (0, import_react.useRef)(void 0);
+  const sourceIdRef = (0, import_react.useRef)(void 0);
+  const interactiveLayerIdsRef = (0, import_react.useRef)(interactiveLayerIds);
+  interactiveLayerIdsRef.current = interactiveLayerIds;
+  const handleMouseOut = (0, import_react.useCallback)(() => {
+    if (!(0, import_lodash_es.isNil)(map)) {
+      blurTrackedFeature(map, featureIdRef, sourceIdRef);
+    }
+  }, [map]);
+  const throttledMouseMove = (0, import_react.useMemo)(
+    () => (0, import_lodash_es.throttle)(
+      ({ point }) => {
+        if ((0, import_lodash_es.isNil)(map)) {
+          return;
+        }
+        let features;
+        try {
+          features = map.queryRenderedFeatures(point, {
+            layers: interactiveLayerIdsRef.current
+          }).filter((feature) => !(0, import_associated_features.isAssociatedFeature)(feature.properties.id));
+        } catch {
+          return;
+        }
         const layerId = features?.[0]?.layer?.id;
         const hasHoveredFeatures = !(0, import_lodash_es.isNil)(features) && features.length > 0 && !(0, import_lodash_es.isUndefined)(layerId);
-        const isBaseLayer = import_constants.BASE_LAYER_IDS.includes(layerId);
-        if (hasHoveredFeatures && !isBaseLayer) {
-          map.getCanvas().style.cursor = "pointer";
-          if (!(0, import_lodash_es.isUndefined)(featureId) && !(0, import_lodash_es.isUndefined)(sourceId)) {
-            blurFeature(map, sourceId, featureId);
-          }
-          const minFeature = (0, import_get_min_value_feature.getMinValueFeature)(features);
-          featureId = minFeature.id;
-          sourceId = minFeature.layer.source;
-          if (!(0, import_lodash_es.isUndefined)(featureId)) {
-            hoverFeature(map, sourceId, featureId);
-          }
-        } else {
+        if (!hasHoveredFeatures) {
           map.getCanvas().style.cursor = "grab";
-          if (!(0, import_lodash_es.isUndefined)(featureId) && !(0, import_lodash_es.isUndefined)(sourceId)) {
-            blurFeature(map, sourceId, featureId);
-          }
+          blurTrackedFeature(map, featureIdRef, sourceIdRef);
+          return;
         }
-      }
-    },
-    [featureId, sourceId, map]
+        map.getCanvas().style.cursor = "pointer";
+        blurTrackedFeature(map, featureIdRef, sourceIdRef);
+        const minFeature = (0, import_get_min_value_feature.getMinValueFeature)(features);
+        featureIdRef.current = minFeature.id;
+        sourceIdRef.current = minFeature.layer.source;
+        if (!(0, import_lodash_es.isUndefined)(featureIdRef.current)) {
+          hoverFeature(map, sourceIdRef.current, featureIdRef.current);
+        }
+      },
+      MOUSEMOVE_THROTTLE_MS,
+      { trailing: true }
+    ),
+    [map]
   );
   (0, import_react.useEffect)(() => {
-    map?.on("mousemove", handleMouseMove);
+    map?.on("mousemove", throttledMouseMove);
     map?.on("mouseout", handleMouseOut);
     return () => {
-      map?.off("mousemove", handleMouseMove);
+      throttledMouseMove.cancel();
+      map?.off("mousemove", throttledMouseMove);
       map?.off("mouseout", handleMouseOut);
     };
-  }, []);
+  }, [map, throttledMouseMove, handleMouseOut]);
 };

package/map/hooks/use-layer-before-id.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Returns the maplibre layer id that the current layer should be inserted before,
+ * based on the JSX order of `MapView` children.
+ *
+ * Without this, layers that mount asynchronously (e.g. `{apiData && <ChoroplethLayer>}`)
+ * are appended to the top of the maplibre stack and end up visually above siblings
+ * that mounted earlier — even when JSX puts them first. Passing the returned value as
+ * `beforeId` to a `<Layer>` keeps the rendered stack aligned with JSX order.
+ *
+ * Only returns an id that actually exists in the map right now, so the result is
+ * always safe to pass to `map.addLayer(opts, beforeId)`.
+ */
+export declare const useLayerBeforeId: (layerId: string) => string | undefined;

package/map/hooks/{use-map-mouse-move.js → use-layer-before-id.js}

@@ -16,23 +16,28 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var use_map_mouse_move_exports = {};
-__export(use_map_mouse_move_exports, {
-  useMapMouseMove: () => useMapMouseMove
+var use_layer_before_id_exports = {};
+__export(use_layer_before_id_exports, {
+  useLayerBeforeId: () => useLayerBeforeId
 });
-module.exports = __toCommonJS(use_map_mouse_move_exports);
+module.exports = __toCommonJS(use_layer_before_id_exports);
 var import_react_maplibre = require("@vis.gl/react-maplibre");
 var import_react = require("react");
-const useMapMouseMove = (layerIds, callback) => {
+var import_layer_ids_context = require("../contexts/layer-ids.context.js");
+const useLayerBeforeId = (layerId) => {
+  const layerIds = (0, import_react.useContext)(import_layer_ids_context.LayerIdsContext);
   const { current: map } = (0, import_react_maplibre.useMap)();
-  (0, import_react.useEffect)(() => {
-    layerIds.forEach((layerId) => {
-      map?.on("mousemove", layerId, callback);
-    });
-    return () => {
-      layerIds.forEach((layerId) => {
-        map?.off("mousemove", layerId, callback);
-      });
-    };
-  });
+  if (!map) {
+    return void 0;
+  }
+  const currentIndex = layerIds.indexOf(layerId);
+  if (currentIndex === -1) {
+    return void 0;
+  }
+  for (let i = currentIndex + 1; i < layerIds.length; i++) {
+    if (map.getLayer(layerIds[i])) {
+      return layerIds[i];
+    }
+  }
+  return void 0;
 };

package/map/hooks/use-map-runtime-error.d.ts

@@ -0,0 +1,34 @@
+export interface UseMapRuntimeErrorOptions {
+    /**
+     * Called when the retry budget (3 attempts) is exhausted and the map cannot
+     * recover. Throwing inside this callback will propagate to the nearest React
+     * ErrorBoundary, showing the fallback UI.
+     */
+    onError: () => void;
+    /**
+     * Optional callback invoked on each recoverable error attempt before the
+     * budget is exhausted. The `attempt` argument is 1-indexed.
+     */
+    onRetry?: (attempt: number) => void;
+}
+/**
+ * Unified hook that guards MapView against maplibre-gl runtime errors from
+ * three distinct sources:
+ *
+ * 1. **WebGL context loss** (`webglcontextlost` on the canvas) — composed via
+ *    `useWebGLContextError`.
+ * 2. **maplibre's own error events** (`map.on('error', ...)`), covering tile
+ *    load failures and other internally dispatched errors.
+ * 3. **Synchronous throws from the rAF render loop** that escape to
+ *    `window.onerror` — shader compilation, program link, and feature-index
+ *    out-of-bounds errors that maplibre does not catch internally.
+ *
+ * A shared retry counter (max 3) is maintained across all sources. Error
+ * counting is debounced at 500 ms so that a burst of errors within a single
+ * render frame counts as one occurrence. The counter resets whenever the map
+ * fires an `idle` event (indicating a successful render). Once the budget is
+ * exhausted, `onError` is invoked.
+ *
+ * APPDEV-17938
+ */
+export declare const useMapRuntimeError: ({ onError, onRetry, }: UseMapRuntimeErrorOptions) => void;

package/map/hooks/use-map-runtime-error.js

@@ -0,0 +1,112 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var use_map_runtime_error_exports = {};
+__export(use_map_runtime_error_exports, {
+  useMapRuntimeError: () => useMapRuntimeError
+});
+module.exports = __toCommonJS(use_map_runtime_error_exports);
+var import_react_maplibre = require("@vis.gl/react-maplibre");
+var import_react = require("react");
+var import_use_webgl_context_error = require("./use-webgl-context-error.js");
+const MAX_RETRIES = 3;
+const ERROR_DEBOUNCE_MS = 500;
+const MAPLIBRE_RUNTIME_ERROR_PATTERNS = [
+  "Could not compile fragment shader",
+  "Could not compile vertex shader",
+  "Program failed to link",
+  "feature index out of bounds",
+  "Out of bounds. Index requested"
+];
+const isMaplibreRuntimeError = (message) => MAPLIBRE_RUNTIME_ERROR_PATTERNS.some((pattern) => message.includes(pattern));
+const useMapRuntimeError = ({
+  onError,
+  onRetry
+}) => {
+  const { current: mapRef } = (0, import_react_maplibre.useMap)();
+  const retryCountRef = (0, import_react.useRef)(0);
+  const lastErrorTimeRef = (0, import_react.useRef)(0);
+  const isMapActiveRef = (0, import_react.useRef)(true);
+  const onErrorRef = (0, import_react.useRef)(onError);
+  onErrorRef.current = onError;
+  const onRetryRef = (0, import_react.useRef)(onRetry);
+  onRetryRef.current = onRetry;
+  const handleError = (0, import_react.useCallback)(() => {
+    const now = Date.now();
+    if (now - lastErrorTimeRef.current < ERROR_DEBOUNCE_MS) {
+      return;
+    }
+    lastErrorTimeRef.current = now;
+    retryCountRef.current += 1;
+    if (retryCountRef.current >= MAX_RETRIES) {
+      onErrorRef.current();
+    } else {
+      onRetryRef.current?.(retryCountRef.current);
+    }
+  }, []);
+  (0, import_use_webgl_context_error.useWebGLContextError)(handleError);
+  (0, import_react.useEffect)(() => {
+    const map = mapRef?.getMap();
+    if (!map) {
+      return;
+    }
+    const handleMapError = ({ error }) => {
+      if (isMaplibreRuntimeError(error.message)) {
+        handleError();
+      }
+    };
+    map.on("error", handleMapError);
+    return () => {
+      map.off("error", handleMapError);
+    };
+  }, [mapRef, handleError]);
+  (0, import_react.useEffect)(() => {
+    const handleWindowError = (event) => {
+      if (!isMapActiveRef.current) {
+        return;
+      }
+      if (isMaplibreRuntimeError(event.message)) {
+        event.preventDefault();
+        handleError();
+      }
+    };
+    window.addEventListener("error", handleWindowError);
+    return () => {
+      window.removeEventListener("error", handleWindowError);
+    };
+  }, [handleError]);
+  (0, import_react.useEffect)(() => {
+    const map = mapRef?.getMap();
+    if (!map) {
+      return;
+    }
+    const handleRender = () => {
+      isMapActiveRef.current = true;
+    };
+    const handleIdle = () => {
+      isMapActiveRef.current = false;
+      retryCountRef.current = 0;
+    };
+    map.on("render", handleRender);
+    map.on("idle", handleIdle);
+    return () => {
+      map.off("render", handleRender);
+      map.off("idle", handleIdle);
+    };
+  }, [mapRef]);
+};

package/map/hooks/use-overlay-events.js

@@ -21,7 +21,9 @@ __export(use_overlay_events_exports, {
   useOverlayEvents: () => useOverlayEvents
 });
 module.exports = __toCommonJS(use_overlay_events_exports);
+var import_react = require("react");
 var import_charts = require("@dynatrace/strato-components/charts");
+var import_geo_data_lookup_context = require("../contexts/geo-data-lookup.context.js");
 var import_store = require("../store/store.js");
 var import_build_geo_tooltip_state = require("../utils/build-geo-tooltip-state.js");
 var import_parse_tooltip_data = require("../utils/parse-tooltip-data.js");
@@ -38,6 +40,7 @@ const layerIdToGeometry = (layerId) => {
   return "geoDot";
 };
 const useOverlayEvents = () => {
+  const dataLookupRegistry = (0, import_react.useContext)(import_geo_data_lookup_context.GeoDataLookupContext);
   const setOverlayState = (0, import_store.useSetStateOverlay)();
   const setState = (0, import_store.useSetState)();
   const dispatch = (0, import_charts._useOverlayTooltipReducer)();
@@ -72,7 +75,10 @@ const useOverlayEvents = () => {
       if (currentState.pinned) {
         return;
       }
-      const { data, hoveredLayerId } = (0, import_parse_tooltip_data.extractDataFromEvent)(event);
+      const { data, hoveredLayerId } = (0, import_parse_tooltip_data.extractDataFromEvent)(
+        event,
+        dataLookupRegistry
+      );
       overlay.clear();
       setTooltipMarker(hoveredLayerId, event.lngLat);
       const pos = getAbsolutePosition(event);
@@ -102,7 +108,10 @@ const useOverlayEvents = () => {
     }
   };
   const handleMouseClick = (event) => {
-    const { data, featureId, hoveredLayerId } = (0, import_parse_tooltip_data.extractDataFromEvent)(event);
+    const { data, featureId, hoveredLayerId } = (0, import_parse_tooltip_data.extractDataFromEvent)(
+      event,
+      dataLookupRegistry
+    );
     if (!featureId) {
       hideTooltip();
       return;

package/map/hooks/use-webgl-context-error.js

@@ -30,7 +30,8 @@ const useWebGLContextError = (onContextLost) => {
     if (!canvas) {
       return;
     }
-    const handleContextLost = () => {
+    const handleContextLost = (event) => {
+      event.preventDefault();
       onContextLost?.();
     };
     canvas.addEventListener("webglcontextlost", handleContextLost);

package/map/slots/Tooltip.d.ts

@@ -4,11 +4,13 @@ import type { ChartTooltip } from '../types/tooltip.js';
  * Tooltip is responsible for exposing the
  * ChartTooltip props, such as, sections, to the consumer
  * @public
+ * @deprecated Use `ChartTooltip` from `@dynatrace/strato-components/charts` instead. Removal: APPDEV-17834
  */
 export declare const Tooltip: ChartTooltip;
 /**
  * TooltipAtoms is responsible for exposing the
  * ChartTooltip atoms.
  * @public
+ * @deprecated Use `ChartTooltip` from `@dynatrace/strato-components/charts` instead. Removal: APPDEV-17834
  */
 export declare const TooltipAtoms: ChartTooltipAtomsType;

package/map/types/connection-layer.d.ts

@@ -53,12 +53,12 @@ export type InternalConnectionLayerProps<T extends Connection> = ConnectionLayer
 /** @internal */
 export interface FeatureProperties {
     id: string;
+    __dataIndex?: number;
     __lineColor: string;
     __lineHoveredColor: string;
     __lineWidth: number;
     __angle?: number;
     curve?: CurvedLine;
-    path: Location[];
 }
 export type GeoJSONFeature<T extends GeoJSON.Geometry> = GeoJSON.Feature<T, FeatureProperties>;
 /**
@@ -79,10 +79,3 @@ export interface ConnectionColorProps<T extends Connection> {
      */
     color?: string | ((connection: T) => string);
 }
-/** @internal */
-export type ConnectionTooltipStatePayload = {
-    path: Location[];
-    __lineColor: string;
-    __lineWidth: number;
-    __nullValues: string[] | undefined;
-};

package/map/types/tooltip.d.ts

@@ -145,5 +145,6 @@ export interface ChoroplethLayerTooltipHandlerProps {
 /**
  * Map Geo Tooltip Props
  * @public
+ * @deprecated Use `ChartTooltip` from `@dynatrace/strato-components/charts` instead. Removal: APPDEV-17834
  */
 export type ChartTooltip = ChartTooltipSlotsType & ChartTooltipTemplateType;

package/map/utils/attach-image-from-shape.js

@@ -25,20 +25,22 @@ var import_attach_image_to_map = require("./attach-image-to-map.js");
 var import_create_bitmap_config_options = require("./create-bitmap-config-options.js");
 var import_get_data_uri = require("./get-data-uri.js");
 var import_constants = require("../constants.js");
+var import_is_browser_firefox = require("./is-browser-firefox.js");
 var import_shape_picker = require("../shapes/shape-picker.js");
 const attachImageFromShape = (map, shape, name, outputSize) => {
   const pickedShape = (0, import_shape_picker.getShape)(shape);
   const stringUrl = (0, import_get_data_uri.getDataUri)(encodeURIComponent(pickedShape));
   const img = new Image(import_constants.DEFAULT_INPUT_ICON_SIZE, import_constants.DEFAULT_INPUT_ICON_SIZE);
   img.addEventListener("load", () => {
-    createImageBitmap(
+    const bitmapPromise = (0, import_is_browser_firefox.isFirefox)() ? createImageBitmap(img, (0, import_create_bitmap_config_options.createBitmapConfigOptions)(outputSize)) : createImageBitmap(
       img,
       0,
       0,
       import_constants.DEFAULT_INPUT_ICON_SIZE,
       import_constants.DEFAULT_INPUT_ICON_SIZE,
       (0, import_create_bitmap_config_options.createBitmapConfigOptions)(outputSize)
-    ).then((bitmap) => {
+    );
+    bitmapPromise.then((bitmap) => {
       if (!map) {
         return;
       }

package/map/utils/extract-layers-data.d.ts

@@ -1,4 +1,5 @@
 import { type ReactNode } from 'react';
+import type { GeoDataLookupRegistry } from '../contexts/geo-data-lookup.context.js';
 /**
  * Extract layers data
  * @param children - MapView children
@@ -9,4 +10,5 @@ export declare const extractLayersData: (children: ReactNode, valueAccessors: Ma
     flattenData: Record<string, unknown>[];
     categories: string[];
     legendDomain: [number, number];
+    dataLookupRegistry: GeoDataLookupRegistry;
 };

package/map/utils/extract-layers-data.js

@@ -47,17 +47,20 @@ const extractLayersData = (children, valueAccessors) => {
   let flattenData = [];
   const categoriesSet = /* @__PURE__ */ new Set();
   let legendDomain = [Infinity, -Infinity];
+  const dataLookupRegistry = /* @__PURE__ */ new Map();
   import_react.Children.forEach(children, (child) => {
     if ((0, import_is_component.isComponent)(child, import_BubbleLayer.BubbleLayer) || (0, import_is_component.isComponent)(child, import_DotLayer.DotLayer)) {
-      const { data } = child.props;
-      data.forEach((dataPoint) => {
+      const { data, layerId } = child.props;
+      const lookup = /* @__PURE__ */ new Map();
+      data.forEach((dataPoint, index) => {
+        lookup.set(index, dataPoint);
         const extendedDataPoint = {
           ...dataPoint,
-          "layer-name": child.props.layerId
+          "layer-name": layerId
         };
         const category = addCategory(
           extendedDataPoint,
-          valueAccessors.get(child.props.layerId)
+          valueAccessors.get(layerId)
         );
         category && categoriesSet.add(category);
         if (typeof category === "number") {
@@ -65,14 +68,14 @@ const extractLayersData = (children, valueAccessors) => {
         }
         flattenData = flattenData.concat(extendedDataPoint);
       });
+      dataLookupRegistry.set(`source-${layerId}`, lookup);
     } else if ((0, import_is_component.isComponent)(child, import_ConnectionLayer.ConnectionLayer)) {
-      const { data } = child.props;
+      const { data, layerId } = child.props;
+      const lookup = /* @__PURE__ */ new Map();
       data.forEach((connection, connectionIndex) => {
+        lookup.set(connectionIndex, connection);
         if (connection.path.length >= 2) {
-          const category = addCategory(
-            connection,
-            valueAccessors.get(child.props.layerId)
-          );
+          const category = addCategory(connection, valueAccessors.get(layerId));
           category && categoriesSet.add(category);
           if (typeof category === "number") {
             legendDomain = updateDomain(legendDomain, category);
@@ -82,24 +85,28 @@ const extractLayersData = (children, valueAccessors) => {
               ...path,
               "connection-name": `connection-${connectionIndex + 1}`,
               "connection-item-index": pathIndex,
-              "layer-name": child.props.layerId
+              "layer-name": layerId
             };
             flattenData.push(parsedPath);
           });
         }
       });
+      dataLookupRegistry.set(`source-${layerId}`, lookup);
     } else if ((0, import_is_component.isComponent)(child, import_ChoroplethLayer.ChoroplethLayer)) {
-      const { data, regionAccessor } = child.props;
-      data.forEach((dataEntry) => {
+      const { data, regionAccessor, layerId } = child.props;
+      const sourceId = layerId.replace("layer", "source");
+      const lookup = /* @__PURE__ */ new Map();
+      data.forEach((dataEntry, index) => {
+        lookup.set(index, dataEntry);
         const region = (0, import_lodash_es.isString)(regionAccessor) ? dataEntry[regionAccessor] : regionAccessor(dataEntry);
         const choroplethLayerData = {
           ...dataEntry,
           region,
-          "layer-name": child.props.layerId
+          "layer-name": layerId
         };
         const category = addCategory(
           choroplethLayerData,
-          valueAccessors.get(child.props.layerId)
+          valueAccessors.get(layerId)
         );
         category && categoriesSet.add(category);
         if (typeof category === "number") {
@@ -107,11 +114,13 @@ const extractLayersData = (children, valueAccessors) => {
         }
         flattenData.push(choroplethLayerData);
       });
+      dataLookupRegistry.set(sourceId, lookup);
     }
   });
   return {
     flattenData,
     categories: [...categoriesSet],
-    legendDomain
+    legendDomain,
+    dataLookupRegistry
   };
 };

package/map/utils/is-browser-firefox.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @returns true if is firefox browser, false otherwise
+ * @internal
+ */
+export declare function isFirefox(): boolean;

package/map/utils/is-browser-firefox.js

@@ -0,0 +1,26 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var is_browser_firefox_exports = {};
+__export(is_browser_firefox_exports, {
+  isFirefox: () => isFirefox
+});
+module.exports = __toCommonJS(is_browser_firefox_exports);
+function isFirefox() {
+  return typeof navigator !== "undefined" && navigator.userAgent.toLowerCase().includes("firefox");
+}

package/map/utils/parse-tooltip-data.d.ts

@@ -1,10 +1,18 @@
 import type { MapGeoJSONFeature, MapLayerMouseEvent } from 'maplibre-gl';
+import type { GeoDataLookupRegistry } from '../contexts/geo-data-lookup.context.js';
 /**
- * Extracts useful map features data for the tooltip
+ * Extracts useful map features data for the tooltip.
+ *
+ * When a data lookup registry is provided, the full original data
+ * is restored from the `__dataIndex` stored in GeoJSON properties.
+ * This allows GeoJSON features to carry only rendering-relevant
+ * fields while still providing full data for tooltips.
+ *
  * @param features - map features
+ * @param registry - optional data lookup registry for restoring full data
  */
-export declare const parseTooltipData: (features: MapGeoJSONFeature[]) => unknown[];
-export declare const extractDataFromEvent: (event: MapLayerMouseEvent) => {
+export declare const parseTooltipData: (features: MapGeoJSONFeature[], registry?: GeoDataLookupRegistry) => unknown[];
+export declare const extractDataFromEvent: (event: MapLayerMouseEvent, registry?: GeoDataLookupRegistry) => {
     featureId?: undefined;
     hoveredLayerId?: undefined;
     data?: undefined;

package/map/utils/parse-tooltip-data.js

@@ -40,20 +40,35 @@ const parseFeatureProperties = (featureProperties) => {
   }
   return properties;
 };
-const parseTooltipData = (features) => {
+const resolveSourceId = (feature) => feature.source ?? feature.layer?.source;
+const restoreDataFromLookup = (sourceId, dataIndex, registry) => {
+  if (registry === void 0 || sourceId === void 0 || dataIndex === void 0) {
+    return void 0;
+  }
+  const lookup = registry.get(sourceId);
+  return lookup?.get(dataIndex);
+};
+const parseTooltipData = (features, registry) => {
   const data = [];
   for (const feature of features) {
     const properties = parseFeatureProperties(feature.properties);
-    const [latitude, longitude] = feature.geometry.coordinates;
+    const sourceId = resolveSourceId(feature);
+    const { __dataIndex, ...visibleProperties } = properties;
+    const dataIndex = typeof __dataIndex === "number" ? __dataIndex : void 0;
+    const originalData = restoreDataFromLookup(sourceId, dataIndex, registry);
+    const coordinates = feature.geometry.type === "Point" ? {
+      longitude: feature.geometry.coordinates[0],
+      latitude: feature.geometry.coordinates[1]
+    } : {};
     data.push({
-      ...properties,
-      latitude,
-      longitude
+      ...visibleProperties,
+      ...originalData !== void 0 ? { data: originalData } : {},
+      ...coordinates
     });
   }
   return data;
 };
-const extractDataFromEvent = (event) => {
+const extractDataFromEvent = (event, registry) => {
   if (!event.features?.length) {
     return {};
   }
@@ -62,7 +77,7 @@ const extractDataFromEvent = (event) => {
   const hoveredFeatures = event.features.filter(
     (feature2) => feature2.layer.id === hoveredLayerId
   );
-  const data = parseTooltipData(hoveredFeatures);
+  const data = parseTooltipData(hoveredFeatures, registry);
   return {
     featureId: `${hoveredLayerId}-${feature.id}`,
     hoveredLayerId,