@dynatrace/strato-geo 3.5.2 → 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-load-map-base-layer.js

@@ -22,6 +22,7 @@ __export(use_load_map_base_layer_exports, {
 });
 module.exports = __toCommonJS(use_load_map_base_layer_exports);
 var import_react = require("react");
+var import_use_map_view_provider_context = require("./use-map-view-provider-context.js");
 var import_apply_feature_filter_rules = require("../utils/apply-feature-filter-rules.js");
 var import_base_layer_rules = require("../utils/base-layer-rules.js");
 var import_fetch_base_layer_features = require("../utils/fetch-base-layer-features.js");
@@ -34,13 +35,17 @@ const useLoadMapBaseLayer = (baseLayerConfig) => {
   const [isMapEnabled, setIsMapEnabled] = (0, import_react.useState)(false);
   const [baseFeatureCollection, setBaseFeatureCollection] = (0, import_react.useState)(void 0);
   const [error, setError] = (0, import_react.useState)(false);
+  const {
+    countryCode: providerCountryCode,
+    displayWorldMap: providerDisplayWorldMap
+  } = (0, import_use_map_view_provider_context.useMapViewProviderContext)();
   const getData = (0, import_react.useCallback)(async () => {
     setIsFetchingFeatures(true);
-    const isMapEnabledResponse = await (0, import_fetch_client_config_map_enabled.fetchClientConfigMapEnabled)();
+    const isMapEnabledResponse = providerDisplayWorldMap ?? await (0, import_fetch_client_config_map_enabled.fetchClientConfigMapEnabled)();
     setIsMapEnabled(isMapEnabledResponse);
     try {
       if (isMapEnabledResponse) {
-        const tenantCountryCode = await (0, import_get_tenant_country_code.getTenantCountryCode)();
+        const tenantCountryCode = providerCountryCode ?? await (0, import_get_tenant_country_code.getTenantCountryCode)();
         const { includeWorldView, countryRegions } = (0, import_get_base_layer_shapes_request_config.getBaseLayerShapesRequestConfig)(baseLayerConfig.include);
         const featuresRequests = [];
         if (includeWorldView) {
@@ -71,7 +76,12 @@ const useLoadMapBaseLayer = (baseLayerConfig) => {
       setError(true);
     }
     setIsFetchingFeatures(false);
-  }, [baseLayerConfig.include, baseLayerConfig.exclude]);
+  }, [
+    baseLayerConfig.include,
+    baseLayerConfig.exclude,
+    providerCountryCode,
+    providerDisplayWorldMap
+  ]);
   (0, import_react.useEffect)(() => {
     getData();
   }, [getData]);

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-map-view-provider-context.d.ts

@@ -0,0 +1 @@
+export declare const useMapViewProviderContext: () => import("../index.js").MapViewProviderProps;

package/map/hooks/use-map-view-provider-context.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 use_map_view_provider_context_exports = {};
+__export(use_map_view_provider_context_exports, {
+  useMapViewProviderContext: () => useMapViewProviderContext
+});
+module.exports = __toCommonJS(use_map_view_provider_context_exports);
+var import_react = require("react");
+var import_map_view_provider_context = require("../contexts/map-view-provider.context.js");
+const useMapViewProviderContext = () => (0, import_react.useContext)(import_map_view_provider_context.MapViewProviderContext);

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-tooltip-template.d.ts

@@ -12,4 +12,12 @@ export declare const isDefaultTooltipHandler: (handler: LayerTooltipHandler) =>
  * @param children -
  * @param layerType -
  */
+export interface TooltipTemplateResult {
+    handler: LayerTooltipHandler | undefined;
+    hidden?: boolean;
+    symbolAlignment?: 'left' | 'right';
+}
 export declare function useTooltipTemplate<T>(children: ReactNode | undefined, layerType: string | JSXElementConstructor<T>): LayerTooltipHandler | undefined;
+export declare function useTooltipTemplate<T>(children: ReactNode | undefined, layerType: string | JSXElementConstructor<T>, options: {
+    extractProps: true;
+}): TooltipTemplateResult;

package/map/hooks/use-tooltip-template.js

@@ -42,10 +42,18 @@ const createDefaultHandlerWithActions = (seriesActions) => {
   return handler;
 };
 const isDefaultTooltipHandler = (handler) => handler.__isDefault ?? false;
-function useTooltipTemplate(children, layerType) {
+function useTooltipTemplate(children, layerType, options) {
   let template = void 0;
+  let hidden = void 0;
+  let symbolAlignment = void 0;
   import_react.Children.forEach(children, (child) => {
     if ((0, import_react.isValidElement)(child) && child.type === layerType) {
+      hidden = child.props.hidden;
+      symbolAlignment = child.props.symbolAlignment;
+      if (child.props.hidden) {
+        template = void 0;
+        return;
+      }
       if ((0, import_lodash_es.isNil)(child.props.children)) {
         template = child.props.seriesActions ? createDefaultHandlerWithActions(child.props.seriesActions) : defaultTooltipHandler;
       } else {
@@ -53,5 +61,12 @@ function useTooltipTemplate(children, layerType) {
       }
     }
   });
-  return template;
+  if (options?.extractProps) {
+    return {
+      handler: hidden ? void 0 : template ?? defaultTooltipHandler,
+      hidden,
+      symbolAlignment
+    };
+  }
+  return hidden ? void 0 : template ?? defaultTooltipHandler;
 }

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/index.d.ts

@@ -25,3 +25,5 @@ export { ThresholdLegend } from './slots/ThresholdLegend.js';
 export { CategoricalLegend } from './slots/CategoricalLegend.js';
 export type { BubbleLayerTooltipHandler, BubbleLayerTooltipHandlerProps, DotLayerTooltipHandler, DotLayerTooltipHandlerProps, ConnectionLayerTooltipHandler, ConnectionLayerTooltipHandlerProps, ChoroplethLayerTooltipHandlerProps, ChoroplethLayerTooltipHandler, ChartTooltip, DotLayerTooltipData, BubbleLayerTooltipData, ConnectionLayerTooltipData, ChoroplethLayerTooltipData, } from './types/tooltip.js';
 export { getAllCountries } from './utils/get-all-countries.js';
+export { MapViewProvider } from './providers/map-view.provider.js';
+export type { MapViewProviderProps } from './types/map-view-provider.js';

package/map/index.js

@@ -27,6 +27,7 @@ __export(map_exports, {
   DotLayer: () => import_DotLayer.DotLayer,
   DownloadCSV: () => import_DownloadCSV.DownloadCSV,
   MapView: () => import_MapView.MapView,
+  MapViewProvider: () => import_map_view_provider.MapViewProvider,
   SequentialLegend: () => import_SequentialLegend.SequentialLegend,
   ThresholdLegend: () => import_ThresholdLegend.ThresholdLegend,
   Tooltip: () => import_Tooltip.Tooltip,
@@ -47,3 +48,4 @@ var import_SequentialLegend = require("./slots/SequentialLegend.js");
 var import_ThresholdLegend = require("./slots/ThresholdLegend.js");
 var import_CategoricalLegend = require("./slots/CategoricalLegend.js");
 var import_get_all_countries = require("./utils/get-all-countries.js");
+var import_map_view_provider = require("./providers/map-view.provider.js");

package/map/providers/map-view.provider.d.ts

@@ -0,0 +1,7 @@
+import { type PropsWithChildren } from 'react';
+import type { MapViewProviderProps } from '../types/map-view-provider.js';
+/**
+ * The `MapViewProvider` is a component that provides shared configuration to nested `MapView` instances.
+ * @public
+ */
+export declare const MapViewProvider: ({ children, countryCode, displayWorldMap, }: PropsWithChildren<MapViewProviderProps>) => import("react/jsx-runtime").JSX.Element;

package/map/providers/map-view.provider.js

@@ -0,0 +1,37 @@
+"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 map_view_provider_exports = {};
+__export(map_view_provider_exports, {
+  MapViewProvider: () => MapViewProvider
+});
+module.exports = __toCommonJS(map_view_provider_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+var import_map_view_provider_context = require("../contexts/map-view-provider.context.js");
+const MapViewProvider = ({
+  children,
+  countryCode,
+  displayWorldMap
+}) => {
+  const value = (0, import_react.useMemo)(
+    () => ({ countryCode, displayWorldMap }),
+    [countryCode, displayWorldMap]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_map_view_provider_context.MapViewProviderContext.Provider, { value, children });
+};

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/map-view-provider.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The `MapViewProvider` props.
+ * @public
+ */
+export type MapViewProviderProps = {
+    /** Country code for regions with disputed borders */
+    countryCode?: 'CN' | 'IN' | 'IL' | 'MA';
+    /** Whether the world map is displayed */
+    displayWorldMap?: boolean;
+};

package/map/types/map-view-provider.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 map_view_provider_exports = {};
+module.exports = __toCommonJS(map_view_provider_exports);