@fundar/data-chart-telling 0.0.63 → 1.0.0

package/dist/plots/geo/Plot.svelte

@@ -1,328 +1,107 @@
 <script lang="ts" generics="TProps extends Record<string, unknown>">
-  import { SvelteMap } from 'svelte/reactivity';
-  import { resolveAccessor } from '../utils/accessors';
-  import { resolveFeatureStyle } from '../utils/geoSegments';
-  import { geometryCentroid, filterGeometryParts, defaultFeatureId } from '../utils/geoAccessors';
-  import { isTopology, topologyToGeoJson } from '../utils/topojson';
-  import { makeColorScale } from '../../utils/color';
-  import { getConfiguration } from '../../configuration/config.svelte';
-  import { getLegendInteraction } from '../../layout/legend/interaction.svelte';
-  import { disabledFillOverride } from '../utils/legendDisabled';
-  import { GEO_MARGIN_ESTIMATE } from '../../layout/coordinates/margins';
-  import { buildGeoMarkers } from './buildGeoMarkers';
-  import { hasHoverMarker } from '../../layout/tooltip/utils';
-  import BasePlotLayout from '../../layout/plot/BasePlotLayout.svelte';
-  import type { BasePlotProps } from '../../types/plots/props';
-  import type { GeoScalesConfig, CoordinatesConfig } from '../../types/layout/coordinates';
-  import type { GeoFeature, GeoDataProps } from '../../types/plots/data/geo';
-  import type { GeoStylesConfig } from '../../types/layout/styles';
-  import type { GeoSegmentStyle } from '../../types/plots/segments/common';
-  import type { GeoMarkersConfig } from '../../types/markers/geo';
-
-  /**
-   * A map, rendered from GeoJSON or TopoJSON. Unlike the other plot kinds
-   * there's no x/y/z axis pair: `data` IS the map. `segments` styles
-   * features by id; `value` + `scales.color`/`styles.colors` drive a
-   * continuous choropleth ramp. Everything drawn on top — points, arrows,
-   * links, contours, graticule/sphere — is a `markers` entry, assembled by
-   * `buildGeoMarkers` and routed through `GeometryLayout`.
-   */
-  type TaggedFeature = GeoFeature<TProps> & { __id: string; __cx: number; __cy: number };
-
-  type Props = BasePlotProps<
-    GeoDataProps<TProps>,
-    GeoFeature<TProps>,
-    GeoStylesConfig<TProps>,
-    GeoSegmentStyle,
-    GeoMarkersConfig,
-    GeoScalesConfig,
-    CoordinatesConfig
-  >;
-
-  let {
-    data,
-    object,
-    featureId,
-    value,
-    excludeParts,
-    width,
-    height,
-    styles = {},
-    segments = {},
-    markers = [],
-    scales = {},
-    coordinates = {},
-    margins,
-    tooltip = undefined,
-  }: Props = $props();
-
-  const cfg = $derived(getConfiguration());
-
-  // ── Resolve data: GeoJSON is synchronous, TopoJSON is converted async ────
-  let topoFeatures = $state<GeoFeature<TProps>[] | null>(null);
-
-  $effect(() => {
-    if (!isTopology(data)) return;
-    if (!object) {
-      console.warn('GeoPlot: `data` is a TopoJSON Topology but no `object` key was given — nothing will render.');
-      topoFeatures = [];
-      return;
-    }
-    let cancelled = false;
-    topologyToGeoJson<TProps>(data, object)
-      .then((resolved) => {
-        if (!cancelled) topoFeatures = resolved;
-      })
-      .catch((err) => {
-        if (!cancelled) {
-          console.warn(err instanceof Error ? err.message : String(err));
-          topoFeatures = [];
-        }
-      });
-    return () => {
-      cancelled = true;
-    };
-  });
-
-  const rawFeatures = $derived.by((): GeoFeature<TProps>[] => {
-    if (isTopology(data)) return topoFeatures ?? [];
-    if (Array.isArray(data)) return data;
-    // `FeatureCollection.features` is GeoJSON's own `Feature<G, P>[]`, without
-    // the `Record<string, unknown>` intersection `GeoFeature` adds to satisfy
-    // this package's generic row-type bound — safe to assert, since every
-    // property `GeoFeature` promises is already present.
-    return data.features as GeoFeature<TProps>[];
-  });
-
-  const getFeatureId = $derived(
-    featureId ? resolveAccessor<GeoFeature<TProps>>(featureId) : defaultFeatureId<TProps>,
-  );
-
-  /**
-   * Tags each feature with a plain enumerable `__id`/`__cx`/`__cy`, so
-   * per-row metadata (feature id for style/hover lookups, centroid for
-   * positioning) lives as an own property on the object itself rather than a
-   * side lookup. Untouched by `excludeParts`: passed to `InsetMarker` as-is,
-   * so an inset can show a part the main map's own rendering (`features`,
-   * below) excludes.
-   */
-  const allFeatures = $derived.by((): TaggedFeature[] =>
-    rawFeatures.map((f) => {
-      const [cx, cy] = geometryCentroid(f.geometry);
-      return { ...f, __id: getFeatureId(f), __cx: cx, __cy: cy } as TaggedFeature;
-    }),
-  );
-
-  /**
-   * `allFeatures`, reduced per `excludeParts` — this is what actually
-   * renders (`styleGroups`/the base `'geo'` marker below) and what
-   * `hoverPoints` derives from. A feature reduced to no parts at all is
-   * dropped entirely.
-   */
-  const features = $derived.by((): TaggedFeature[] => {
-    if (!excludeParts) return allFeatures;
-    return allFeatures.flatMap((f) => {
-      const geometry = filterGeometryParts(f.geometry, (part) => !excludeParts(part, f));
-      if (!geometry) return [];
-      const [cx, cy] = geometryCentroid(geometry);
-      return [{ ...f, geometry, __cx: cx, __cy: cy } as TaggedFeature];
-    });
-  });
-
-  // ── Tile-layer / projection compatibility ────────────────────────────────
-  $effect(() => {
-    if (!styles.tileLayer) return;
-    const proj = coordinates.projection;
-    const name = typeof proj === 'string' ? proj : proj?.type;
-    if (name && name !== 'mercator' && name !== 'transverse-mercator') {
-      console.warn(
-        `GeoPlot: styles.tileLayer only renders correctly with a mercator-family projection — got "${name}". Rendering anyway.`,
-      );
-    }
-  });
-
-  /**
-   * `coordinates.projection`, defaulted to `'mercator'` when unset and
-   * `styles.tileLayer` is active (the only projection family `TileLayer`
-   * renders correctly under) — folded in here, before `coordinates` reaches
-   * `BasePlotLayout`/`CoordinatesLayout`, since neither knows about
-   * `styles.tileLayer`.
-   */
-  const resolvedCoordinates = $derived.by((): CoordinatesConfig => ({
-    ...coordinates,
-    projection: coordinates.projection ?? (styles.tileLayer ? 'mercator' : undefined),
-  }));
-
-  /**
-   * `styles`, with `features` tacked onto `tileLayer` (never author-facing —
-   * `GeoTileLayerConfig` doesn't declare it) so `StylesLayout` can compute
-   * the tile layer's auto-fit bounds without raw geometry threaded through
-   * as a separate prop. `excludeParts`-reduced `features`, matching what
-   * actually renders.
-   */
-  const resolvedStyles = $derived.by(() =>
-    styles.tileLayer ? { ...styles, tileLayer: { ...styles.tileLayer, features } } : styles,
-  );
-
-  // ── Choropleth color scale (mirrors heatmap's styles.colors/scales.z) ────
-  const minColor = $derived(styles.colors?.min ?? cfg.continuous.min);
-  const maxColor = $derived(styles.colors?.max ?? cfg.continuous.max);
-
-  const valueDomain = $derived.by((): [number, number] | null => {
-    if (scales.color?.domain) return scales.color.domain;
-    if (!value) return null;
-    const vals = features.map((f) => value(f)).filter((v): v is number => v != null);
-    return vals.length ? [Math.min(...vals), Math.max(...vals)] : null;
-  });
-
-  // ── Legend-driven range filter (mirrors HeatmapPlot's own) ────────────────
-  const legendInteraction = $derived(getLegendInteraction());
-  const range = $derived(legendInteraction?.continuousRange);
-  const effectiveDomain = $derived.by((): [number, number] | null => {
-    if (!valueDomain) return null;
-    return range && range.mode === 'rescale' ? [range.min, range.max] : valueDomain;
-  });
-
-  const colorScale = $derived(
-    effectiveDomain ? makeColorScale(effectiveDomain[0], effectiveDomain[1], minColor, maxColor) : null,
-  );
-
-  function resolveBaseFill(f: TaggedFeature): string {
-    if (value && colorScale) {
-      const v = value(f);
-      if (v != null) return colorScale(v);
-    }
-    return styles.fill ?? cfg.palette[0];
-  }
-
-  function rangeFilteredStyle(base: GeoSegmentStyle, f: TaggedFeature): GeoSegmentStyle {
-    const r = range;
-    if (r == null || !value) return base;
-    const v = value(f);
-    if (v == null || (v >= r.min && v <= r.max)) return base;
-    return { ...base, ...disabledFillOverride(r.disabledStyle) };
-  }
-
-  // ── Per-feature style resolution, grouped by distinct resolved style ─────
-  // (one `'geo'` marker per group — mirrors heatmap's styleGroups: svelteplot's
-  // shared numeric-scale machinery collapses a per-row fillOpacity/strokeWidth
-  // *accessor* to a single value, so literal per-call constants are required.)
-  function getFeatureStyle(f: TaggedFeature): GeoSegmentStyle {
-    return rangeFilteredStyle(resolveFeatureStyle<GeoSegmentStyle>(segments, f.__id), f);
-  }
-
-  type StyleGroup = { style: GeoSegmentStyle; data: TaggedFeature[] };
-  const styleGroups = $derived.by((): StyleGroup[] => {
-    const groups = new SvelteMap<string, StyleGroup>();
-    for (const f of features) {
-      const style = getFeatureStyle(f);
-      const key = JSON.stringify(style);
-      let group = groups.get(key);
-      if (!group) {
-        group = { style, data: [] };
-        groups.set(key, group);
-      }
-      group.data.push(f);
-    }
-    return [...groups.values()];
-  });
-
-  // A feature outside the active range is dimmed in place, but never
-  // surfaces in hover/tooltip — it's simply absent from the candidate list.
-  const hoverPoints = $derived(
-    features
-      .filter((f) => {
-        const r = range;
-        if (r == null || !value) return true;
-        const v = value(f);
-        return v == null || (v >= r.min && v <= r.max);
-      })
-      .map((f) => ({ x: f.__cx, y: f.__cy, row: f, label: f.__id })),
-  );
-  const hoverGetX = (f: TaggedFeature) => f.__cx;
-  const hoverGetY = (f: TaggedFeature) => f.__cy;
-
-  /**
-   * `hoverPoints` keyed by feature `__id`, looked up from the exact feature
-   * the browser's own SVG hit-testing resolved a pointer event to (see the
-   * base `'geo'` marker's `onpointerenter`, built by `buildGeoMarkers`). A
-   * feature absent here was filtered out of `hoverPoints` and correctly
-   * produces no match.
-   */
-  const hoverPointById = $derived.by(() => {
-    const map = new SvelteMap<string, (typeof hoverPoints)[number]>();
-    for (const p of hoverPoints) map.set(p.row.__id, p);
-    return map;
-  });
-
-  const hoverActive = $derived(tooltip != null || hasHoverMarker(markers));
-
-  const hover = $derived({
-    active: hoverActive,
-    points: hoverPoints,
-    label: (f: TaggedFeature) => f.__id,
-    strategy: 'punctual' as const,
-    // A map has no axis to draw a crosshair rule against — 'punctual' here
-    // only means "exact XY hover match", unlike heatmap's own use of it.
-    crosshair: false,
-    sync: tooltip?.sync ?? false,
-    tooltip,
-    exclude: isOverInset,
-    // A feature's true visual center can sit far from where the cursor
-    // actually is on a large/irregular shape (e.g. an elongated province) —
-    // 'contains' matches the feature the cursor is really over, via the
-    // browser's own SVG hit-testing on each rendered feature path, rather
-    // than 'nearest' centroid distance.
-    pointMatching: 'contains' as const,
-  });
-
-  /**
-   * The main map's own hover must never fire while the cursor is over an
-   * `inset` marker's panel, which draws at its own scale/projection.
-   * Checked via `e.target` (tagged with the `dct-geo-inset` ancestor class
-   * by `InsetMarker`'s own hit-test elements) rather than precomputed pixel
-   * bounds, since the browser's own hit-testing already accounts for any
-   * scale mismatch between `<Plot>`'s props and its rendered viewBox.
-   */
-  function isOverInset(e: PointerEvent): boolean {
-    return (e.target as Element | null)?.closest?.('.dct-geo-inset') != null;
-  }
+	import Core from './Core.svelte';
+	import Plot from '../../layout/plot/Plot.svelte';
+	import { merge } from '../../utils/merge';
+	import { buildGeoDefaults } from './defaults';
+	import { buildGeoSlicing } from './slices';
+	import { createGeoFeatures } from './features.svelte';
+	import type { GeoPlotProps, GeoPlotCoreProps } from '../../types/plots/geo/props';
+	import type { GeoFeature } from '../../types/plots/data/geo';
+	import type { GeoScalesConfig } from '../../types/layout/coordinates';
+	import type { PlotCellContext } from '../../types/layout/plot';
+	import type { TooltipConfig } from '../../types/plots/props';
+	import type { TooltipProp } from '../../types/layout/tooltip';
+
+	type Row = Record<string, unknown>;
+
+	/**
+	 * A map, rendered from GeoJSON or TopoJSON - `data` is the map itself.
+	 * Optional chrome (`title`, `subtitle`, `caption`, `header`, `footer`,
+	 * `legend`) frames it. `timeline` and `facet` slice its features and its
+	 * markers' own rows by a field (a feature's from its `properties`); what
+	 * lacks the field draws in every slice, and the color ramp spans every
+	 * slice. With `coordinates.projection.domain: 'data'`, each facet zooms to
+	 * its own features.
+	 */
+	let {
+		title,
+		subtitle,
+		caption,
+		header,
+		footer,
+		legend,
+		order,
+		tooltip,
+		timeline,
+		facet,
+		margins = $bindable(),
+		...core
+	}: GeoPlotProps<TProps> = $props();
+
+	const sliced = $derived(timeline != null || facet != null);
+	// Only resolved here when slicing; otherwise the core resolves `data` itself.
+	const resolved = createGeoFeatures<TProps>(
+		() => (sliced ? core.data : []),
+		() => core.object
+	);
+	const features = $derived(resolved.features as unknown as Row[]);
+	const markerRows = $derived(
+		(core.markers ?? []).flatMap((m) =>
+			Array.isArray((m as { data?: unknown }).data) ? ((m as { data: Row[] }).data ?? []) : []
+		)
+	);
+	const slicing = $derived(
+		buildGeoSlicing({ rows: [...features, ...markerRows], timeline, facet })
+	);
+
+	/** The color ramp's domain over every feature, so each slice colors on the same scale. */
+	const sharedColor = $derived.by((): GeoScalesConfig | undefined => {
+		const value = core.color;
+		if (!value) return undefined;
+		const values = (resolved.features as GeoFeature<TProps>[])
+			.map((f) => value(f))
+			.filter((v): v is number => typeof v === 'number' && Number.isFinite(v));
+		return values.length
+			? { color: { domain: [Math.min(...values), Math.max(...values)] } }
+			: undefined;
+	});
+
+	/** The core's props for one slice: the features and marker rows it keeps. */
+	function sliceProps(slice: PlotCellContext<Row>): GeoPlotCoreProps<TProps> {
+		const tip = slice.tooltip as TooltipConfig<GeoFeature<TProps>> | undefined;
+		if (!sliced)
+			return { ...core, width: slice.width, height: slice.height, margins, tooltip: tip };
+		return {
+			...core,
+			data: features.filter(slice.keep) as unknown as GeoFeature<TProps>[],
+			markers: core.markers?.map((m) => {
+				const rows = (m as { data?: unknown }).data;
+				return Array.isArray(rows) ? { ...m, data: (rows as Row[]).filter(slice.keep) } : m;
+			}),
+			width: slice.width,
+			height: slice.height,
+			margins: slice.margins ?? margins,
+			scales: merge(sharedColor, core.scales),
+			tooltip: tip
+		} as GeoPlotCoreProps<TProps>;
+	}
 </script>
 
-<!--
-  `x`/`y`: pins the plot's generic linear scales to the full lon/lat range.
-  Every geo-aware mark routes through the active projection instead, except
-  svelteplot's `Contour`, whose grid reads `plot.scales.x`/`y` directly —
-  this keeps a `contour` marker aligned with the map under it.
--->
-<BasePlotLayout
-  {width}
-  {height}
-  data={features}
-  getX={hoverGetX}
-  getY={hoverGetY}
-  {hover}
-  x={{ domain: [-180, 180] }}
-  y={{ domain: [90, -90] }}
-  coordinates={resolvedCoordinates}
-  {margins}
-  marginEstimate={GEO_MARGIN_ESTIMATE}
-  styles={resolvedStyles}
-  markers={({ setHoverMatch, clearHoverMatch }) =>
-    buildGeoMarkers({
-      styleGroups,
-      resolveBaseFill,
-      fillOpacity: styles.fillOpacity,
-      stroke: styles.stroke,
-      strokeWidth: styles.strokeWidth,
-      axisColor: cfg.axis.color,
-      onFeatureClick: styles.onFeatureClick,
-      markers,
-      hoverActive,
-      hoverPointById,
-      isOverInset,
-      setHoverMatch,
-      clearHoverMatch,
-    })}
-  geoAllFeatures={allFeatures}
+<Plot
+	{Core}
+	core={core as GeoPlotCoreProps<TProps>}
+	defaults={buildGeoDefaults}
+	slice={sliceProps}
+	bind:margins
+	{title}
+	{subtitle}
+	{caption}
+	{header}
+	{footer}
+	{legend}
+	{order}
+	timeline={slicing.timeline}
+	facet={slicing.facet}
+	data={slicing.rows}
+	tooltip={tooltip as TooltipProp<Row> | undefined}
 />

package/dist/plots/geo/Plot.svelte.d.ts

@@ -1,13 +1,9 @@
-import type { BasePlotProps } from '../../types/plots/props';
-import type { GeoScalesConfig, CoordinatesConfig } from '../../types/layout/coordinates';
-import type { GeoFeature, GeoDataProps } from '../../types/plots/data/geo';
-import type { GeoStylesConfig } from '../../types/layout/styles';
-import type { GeoSegmentStyle } from '../../types/plots/segments/common';
-import type { GeoMarkersConfig } from '../../types/markers/geo';
+import Plot from '../../layout/plot/Plot.svelte';
+import type { GeoPlotProps } from '../../types/plots/geo/props';
 declare function $$render<TProps extends Record<string, unknown>>(): {
-    props: BasePlotProps<GeoDataProps<TProps>, GeoFeature<TProps>, GeoStylesConfig<TProps>, GeoSegmentStyle, GeoMarkersConfig, GeoScalesConfig, CoordinatesConfig>;
+    props: GeoPlotProps<TProps>;
     exports: {};
-    bindings: "";
+    bindings: "margins";
     slots: {};
     events: {};
 };
@@ -15,7 +11,7 @@ declare class __sveltets_Render<TProps extends Record<string, unknown>> {
     props(): ReturnType<typeof $$render<TProps>>['props'];
     events(): ReturnType<typeof $$render<TProps>>['events'];
     slots(): ReturnType<typeof $$render<TProps>>['slots'];
-    bindings(): "";
+    bindings(): "margins";
     exports(): {};
 }
 interface $$IsomorphicComponent {

package/dist/plots/geo/defaults.d.ts

@@ -0,0 +1,4 @@
+import type { GeoPlotState, GeoPlotCtx } from '../../types/plots/geo/state';
+import { Pipeline } from '../../phases/Pipeline';
+/** GeoPlot's own pipeline (data, scales, markers, tooltip, hover), run over the state its core seeds, hovering one feature at a time. */
+export declare function buildGeoDefaults<TProps extends Record<string, unknown>>(): Pipeline<GeoPlotState<TProps>, GeoPlotCtx<TProps>>;

package/dist/plots/geo/defaults.js

@@ -0,0 +1,16 @@
+import { buildData } from './phases/data';
+import { buildScales } from './phases/scales';
+import { buildMarkers } from './phases/markers';
+import { buildTooltip } from './phases/tooltip';
+import { buildHover } from './phases/hover';
+import { Pipeline } from '../../phases/Pipeline';
+/** GeoPlot's own pipeline (data, scales, markers, tooltip, hover), run over the state its core seeds, hovering one feature at a time. */
+export function buildGeoDefaults() {
+    return new Pipeline([
+        { phase: 'data', run: buildData },
+        { phase: 'scales', run: buildScales },
+        { phase: 'markers', run: buildMarkers },
+        { phase: 'tooltip', run: buildTooltip },
+        { phase: 'hover', run: buildHover }
+    ], { hoverStrategy: 'punctual' });
+}

package/dist/plots/geo/features.svelte.d.ts

@@ -0,0 +1,5 @@
+import type { GeoFeature, GeoJsonInput, Topology } from '../../types/plots/data/geo';
+/** A GeoPlot's `data` as a feature list: GeoJSON as is, a TopoJSON `Topology` converted under `object`. */
+export declare function createGeoFeatures<TProps extends Record<string, unknown>>(getData: () => GeoJsonInput<TProps> | Topology, getObject: () => string | undefined): {
+    readonly features: GeoFeature<TProps>[];
+};

package/dist/plots/geo/features.svelte.js

@@ -0,0 +1,44 @@
+import { isTopology, topologyToGeoJson } from '../utils/topojson';
+/** A GeoPlot's `data` as a feature list: GeoJSON as is, a TopoJSON `Topology` converted under `object`. */
+export function createGeoFeatures(getData, getObject) {
+    let topoFeatures = $state(null);
+    $effect(() => {
+        const data = getData();
+        const object = getObject();
+        if (!isTopology(data))
+            return;
+        if (!object) {
+            console.warn('GeoPlot: `data` is a TopoJSON Topology but no `object` key was given - nothing will render.');
+            topoFeatures = [];
+            return;
+        }
+        let cancelled = false;
+        topologyToGeoJson(data, object)
+            .then((resolved) => {
+            if (!cancelled)
+                topoFeatures = resolved;
+        })
+            .catch((err) => {
+            if (!cancelled) {
+                console.warn(err instanceof Error ? err.message : String(err));
+                topoFeatures = [];
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+    });
+    const features = $derived.by(() => {
+        const data = getData();
+        if (isTopology(data))
+            return topoFeatures ?? [];
+        if (Array.isArray(data))
+            return data;
+        return data.features;
+    });
+    return {
+        get features() {
+            return features;
+        }
+    };
+}

package/dist/plots/geo/phases/data.d.ts

@@ -0,0 +1,6 @@
+import type { GeoPlotState } from '../../../types/plots/geo/state';
+/**
+ * GeoPlot's "data" phase: every feature tagged with its resolved id/centroid,
+ * then reduced by `excludeParts`. Reads no ctx.
+ */
+export declare function buildData<TProps extends Record<string, unknown>>(state: GeoPlotState<TProps>): GeoPlotState<TProps>;

package/dist/plots/geo/phases/data.js

@@ -0,0 +1,26 @@
+import { resolveAccessor } from '../../utils/accessors';
+import { geometryCentroid, filterGeometryParts, defaultFeatureId } from '../../utils/geoAccessors';
+/**
+ * GeoPlot's "data" phase: every feature tagged with its resolved id/centroid,
+ * then reduced by `excludeParts`. Reads no ctx.
+ */
+export function buildData(state) {
+    const { rawFeatures, featureId, excludeParts } = state;
+    const getFeatureId = featureId
+        ? resolveAccessor(featureId)
+        : defaultFeatureId;
+    const allFeatures = rawFeatures.map((f) => {
+        const [cx, cy] = geometryCentroid(f.geometry);
+        return { ...f, __id: getFeatureId(f), __cx: cx, __cy: cy };
+    });
+    const features = !excludeParts
+        ? allFeatures
+        : allFeatures.flatMap((f) => {
+            const geometry = filterGeometryParts(f.geometry, (part) => !excludeParts(part, f));
+            if (!geometry)
+                return [];
+            const [cx, cy] = geometryCentroid(geometry);
+            return [{ ...f, geometry, __cx: cx, __cy: cy }];
+        });
+    return { ...state, allFeatures, features };
+}

package/dist/plots/geo/phases/hover.d.ts

@@ -0,0 +1,9 @@
+import type { GeoPlotState, GeoPlotCtx } from '../../../types/plots/geo/state';
+/** Whether a pointer event is over an `inset` marker's panel, which has its own hover. */
+export declare function isOverInset(e: PointerEvent): boolean;
+/**
+ * GeoPlot's "hover" phase: each feature, at its centroid, matched by the
+ * feature under the cursor and read as its id. A feature outside the active
+ * legend range stays drawn, dimmed, but is never a candidate.
+ */
+export declare function buildHover<TProps extends Record<string, unknown>>(state: GeoPlotState<TProps>, ctx: GeoPlotCtx<TProps>): GeoPlotState<TProps>;

package/dist/plots/geo/phases/hover.js

@@ -0,0 +1,45 @@
+import { HoverPhase } from '../../../phases/hover/HoverPhase';
+/** Whether a pointer event is over an `inset` marker's panel, which has its own hover. */
+export function isOverInset(e) {
+    return e.target?.closest?.('.dct-geo-inset') != null;
+}
+/**
+ * GeoPlot's "hover" phase: each feature, at its centroid, matched by the
+ * feature under the cursor and read as its id. A feature outside the active
+ * legend range stays drawn, dimmed, but is never a candidate.
+ */
+export function buildHover(state, ctx) {
+    const { color, tooltip, authoredMarkers } = state;
+    const { range } = ctx;
+    const features = state.features;
+    const label = (f) => f.__id;
+    const points = features
+        .filter((f) => !range || !color || HoverPhase.inRange(color(f), range))
+        .map((f) => ({ x: f.__cx, y: f.__cy, row: f, label: label(f) }));
+    const hover = {
+        ...HoverPhase.buildHoverConfig({
+            tooltip: tooltip,
+            format: state.tooltipFormat,
+            markers: authoredMarkers,
+            points,
+            label,
+            defaultStrategy: 'punctual',
+            // Match the feature under the cursor, not the nearest centroid.
+            pointMatching: 'contains'
+        }),
+        // A map has no axis to draw a crosshair rule against - 'punctual' here
+        // only means "exact XY hover match", unlike heatmap's own use of it.
+        strategy: 'punctual',
+        crosshair: false,
+        exclude: isOverInset
+    };
+    return {
+        ...state,
+        hover,
+        hoverPosition: {
+            x: (f) => f.__cx,
+            y: (f) => f.__cy
+        },
+        hoverRows: features
+    };
+}

package/dist/plots/geo/phases/markers.d.ts

@@ -0,0 +1,9 @@
+import type { GeoPlotState, GeoPlotCtx } from '../../../types/plots/geo/state';
+/**
+ * GeoPlot's "markers" phase: per-feature style resolution/grouping, the base
+ * `'geo'` marker(s), and the full draw order - any authored marker with
+ * `behind: true`, then the base map, then the rest of the authored markers,
+ * with any `hover` marker moved last. The base marker(s) match the pointer
+ * themselves, over the features inside the legend's range.
+ */
+export declare function buildMarkers<TProps extends Record<string, unknown>>(state: GeoPlotState<TProps>, ctx: GeoPlotCtx<TProps>): GeoPlotState<TProps>;