@fundar/data-chart-telling 1.0.0 → 1.2.0

package/dist/plots/evolution/sparkline/markers.d.ts

@@ -0,0 +1,7 @@
+import type { AxisBasedMarkersConfig } from '../../../types/markers/common';
+import type { SparklinePlotState, SparklinePlotCtx } from '../../../types/plots/evolution/sparkline/state';
+/**
+ * SparklinePlot's "markers" phase: each series' line, thin, and a dot on its
+ * last point with a value.
+ */
+export declare function buildMarks<TData extends Record<string, unknown>>(state: SparklinePlotState<TData>, ctx: SparklinePlotCtx): AxisBasedMarkersConfig[];

package/dist/plots/evolution/sparkline/markers.js

@@ -0,0 +1,56 @@
+import { getConfiguration } from '../../../configuration/config.svelte';
+import { buildLineMarkers } from '../line/markers';
+import { resolveAccessor } from '../../../utils/accessors';
+import { isGapValue } from '../../utils/gaps';
+/**
+ * SparklinePlot's "markers" phase: each series' line, thin, and a dot on its
+ * last point with a value.
+ */
+export function buildMarks(state, ctx) {
+    const { sparkline } = getConfiguration();
+    const groups = state.processedGroups ?? [];
+    const disabledDotsFor = (name) => ctx.interaction?.dotsFor(name);
+    const lines = buildLineMarkers({
+        groupedSeries: groups.map((group) => ({
+            ...group,
+            visualSegments: group.visualSegments.map((segment) => ({
+                ...segment,
+                styles: {
+                    ...segment.styles,
+                    stroke: { strokeWidth: sparkline.strokeWidth, ...segment.styles.stroke }
+                }
+            }))
+        })),
+        colorFor: state.colorForSeries,
+        disabledStrokeFor: (name) => ctx.interaction?.strokeFor(name),
+        disabledDotsFor,
+        curve: state.styles?.curve
+    });
+    const dots = groups.flatMap((group) => {
+        const { series } = group;
+        const value = resolveAccessor(series.y);
+        const last = [...series.data].reverse().find((row) => !isGapValue(value(row)));
+        if (last === undefined)
+            return [];
+        // The dot takes the color of the stretch it ends.
+        const color = group.visualSegments.at(-1)?.styles.stroke?.stroke ?? state.colorForSeries(series.name);
+        const disabled = disabledDotsFor(series.name);
+        return [
+            {
+                type: 'dot',
+                data: [last],
+                x: series.x,
+                y: series.y,
+                styles: {
+                    dotRadius: sparkline.dotRadius,
+                    dotFill: color,
+                    dotStroke: color,
+                    dotStrokeWidth: 1,
+                    dotFillOpacity: disabled?.dotFillOpacity ?? 1,
+                    dotStrokeOpacity: disabled?.dotStrokeOpacity ?? 1
+                }
+            }
+        ];
+    });
+    return [...lines, ...dots];
+}

package/dist/plots/{geo → map/geo}/Core.svelte

@@ -1,13 +1,13 @@
 <script lang="ts" generics="TProps extends Record<string, unknown>">
-	import { createGeoFeatures } from './features.svelte';
-	import { getConfiguration } from '../../configuration/config.svelte';
-	import { LegendState } from '../../layout/legend/LegendState.svelte';
-	import { ChannelName } from '../utils/ChannelName';
-	import { Margins } from '../../layout/margins/Margins';
-	import BasePlotLayout from '../../layout/base/BasePlotLayout.svelte';
-	import type { GeoPlotCoreProps } from '../../types/plots/geo/props';
-	import type { CoordinatesConfig } from '../../types/layout/coordinates';
-	import type { GeoPlotState, GeoPlotCtx } from '../../types/plots/geo/state';
+	import { GeoFeatures } from './GeoFeatures.svelte';
+	import { getConfiguration } from '../../../configuration/config.svelte';
+	import { LegendState } from '../../../layout/legend/LegendState.svelte';
+	import { ChannelName } from '../../utils/ChannelName';
+	import { Margins } from '../../../layout/margins/Margins';
+	import BasePlotLayout from '../../../layout/base/BasePlotLayout.svelte';
+	import type { GeoPlotCoreProps } from '../../../types/plots/map/geo/props';
+	import type { CoordinatesConfig } from '../../../types/layout/coordinates';
+	import type { GeoPlotState, GeoPlotCtx } from '../../../types/plots/map/geo/state';
 
 	/**
 	 * A map from GeoJSON or TopoJSON. `segments` styles features by id,
@@ -39,7 +39,7 @@
 	const cfg = $derived(getConfiguration());
 
 	// ── Resolve data: GeoJSON is synchronous, TopoJSON is converted async ────
-	const resolved = createGeoFeatures<TProps>(
+	const resolved = new GeoFeatures<TProps>(
 		() => data,
 		() => object
 	);
@@ -134,6 +134,7 @@
 			opacity: { source: ChannelName.of(opacity, 'opacity') }
 		},
 		colorDomain: plotState.colorDomain,
+		colorRamps: plotState.colorRamps,
 		opacityDomain: plotState.opacityDomain,
 		styles: resolvedStyles,
 		marginEstimate: Margins.GEO_ESTIMATE

package/dist/plots/{geo → map/geo}/Core.svelte.d.ts

@@ -1,4 +1,4 @@
-import type { GeoPlotCoreProps } from '../../types/plots/geo/props';
+import type { GeoPlotCoreProps } from '../../../types/plots/map/geo/props';
 declare function $$render<TProps extends Record<string, unknown>>(): {
     props: GeoPlotCoreProps<TProps>;
     exports: {};

package/dist/plots/map/geo/GeoFeatures.svelte.d.ts

@@ -0,0 +1,9 @@
+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`. Create it while a component initializes. */
+export declare class GeoFeatures<TProps extends Record<string, unknown>> {
+    #private;
+    constructor(getData: () => GeoJsonInput<TProps> | Topology, getObject: () => string | undefined);
+    get features(): GeoFeature<TProps>[];
+    /** The default `featureId`: `feature.id`, else `properties.id`, else `properties.name`. */
+    static defaultId<TProps extends Record<string, unknown>>(feature: GeoFeature<TProps>): string;
+}

package/dist/plots/map/geo/GeoFeatures.svelte.js

@@ -0,0 +1,55 @@
+import { isTopology, topologyToGeoJson } from '../../utils/topojson';
+/** A GeoPlot's `data` as a feature list: GeoJSON as is, a TopoJSON `Topology` converted under `object`. Create it while a component initializes. */
+export class GeoFeatures {
+    #getData;
+    #getObject;
+    #converted = $state(null);
+    #list = $derived.by(() => {
+        const data = this.#getData();
+        if (isTopology(data))
+            return this.#converted ?? [];
+        if (Array.isArray(data))
+            return data;
+        return data.features;
+    });
+    constructor(getData, getObject) {
+        this.#getData = getData;
+        this.#getObject = getObject;
+        $effect(() => this.#convert());
+    }
+    get features() {
+        return this.#list;
+    }
+    /** The default `featureId`: `feature.id`, else `properties.id`, else `properties.name`. */
+    static defaultId(feature) {
+        const props = feature.properties;
+        return String(feature.id ?? props?.id ?? props?.name ?? '');
+    }
+    /** Converts a TopoJSON `data` into features once, dropping the result if `data` changes meanwhile. */
+    #convert() {
+        const data = this.#getData();
+        const object = this.#getObject();
+        if (!isTopology(data))
+            return;
+        if (!object) {
+            console.warn('GeoPlot: `data` is a TopoJSON Topology but no `object` key was given - nothing will render.');
+            this.#converted = [];
+            return;
+        }
+        let cancelled = false;
+        topologyToGeoJson(data, object)
+            .then((features) => {
+            if (!cancelled)
+                this.#converted = features;
+        })
+            .catch((error) => {
+            if (!cancelled) {
+                console.warn(error instanceof Error ? error.message : String(error));
+                this.#converted = [];
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+    }
+}

package/dist/plots/map/geo/GeoGeometry.d.ts

@@ -0,0 +1,27 @@
+type LonLat = [number, number];
+/** Operations on GeoJSON geometries: their centroids, bounds, disjoint parts and great-circle arcs. */
+export declare class GeoGeometry {
+    #private;
+    /** Bounding-box center of a geometry's coordinates: a cheap point for a label, not an area centroid. */
+    static centroid(geometry: GeoJSON.Geometry): LonLat;
+    /** `[minLon, minLat, maxLon, maxLat]` of a geometry, or `null` when it has no coordinates. */
+    static lonLatBounds(geometry: GeoJSON.Geometry): [number, number, number, number] | null;
+    /** A multi-part geometry as its disjoint parts, one `Polygon` or `LineString` each; any other geometry as itself. */
+    static parts(geometry: GeoJSON.Geometry): GeoJSON.Geometry[];
+    /** One centroid per disjoint part, so a feature whose parts lie far apart matches a hover over any of them. */
+    static partCentroids(geometry: GeoJSON.Geometry): LonLat[];
+    /** The geometry without the parts `keep` rejects, or `null` when none stays. The same geometry when all do. */
+    static filterParts(geometry: GeoJSON.Geometry, keep: (part: {
+        centroid: LonLat;
+        geometry: GeoJSON.Geometry;
+    }) => boolean): GeoJSON.Geometry | null;
+    /** The path between two points that changes longitude and latitude at a steady rate, the short way around: it keeps near its parallels where a great circle bends toward a pole. */
+    static parallelPath(from: LonLat, to: LonLat, steps?: number): LonLat[];
+    /**
+     * The great-circle arc between two points, as `steps + 1` points. Drawn
+     * through `Geo` because svelteplot's `Link` cannot read `x1`/`y1`/`x2`/`y2`
+     * under a projection (0.14.2).
+     */
+    static greatCircle(from: LonLat, to: LonLat, steps?: number): LonLat[];
+}
+export {};

package/dist/plots/map/geo/GeoGeometry.js

@@ -0,0 +1,142 @@
+/** Operations on GeoJSON geometries: their centroids, bounds, disjoint parts and great-circle arcs. */
+export class GeoGeometry {
+    /** Bounding-box center of a geometry's coordinates: a cheap point for a label, not an area centroid. */
+    static centroid(geometry) {
+        const coords = GeoGeometry.#coordinates(geometry);
+        if (coords.length === 0)
+            return [0, 0];
+        const [minLon, minLat, maxLon, maxLat] = GeoGeometry.#extent(coords);
+        return [(minLon + maxLon) / 2, (minLat + maxLat) / 2];
+    }
+    /** `[minLon, minLat, maxLon, maxLat]` of a geometry, or `null` when it has no coordinates. */
+    static lonLatBounds(geometry) {
+        const coords = GeoGeometry.#coordinates(geometry);
+        return coords.length === 0 ? null : GeoGeometry.#extent(coords);
+    }
+    /** A multi-part geometry as its disjoint parts, one `Polygon` or `LineString` each; any other geometry as itself. */
+    static parts(geometry) {
+        switch (geometry.type) {
+            case 'MultiPolygon':
+                return geometry.coordinates.map((polygon) => ({ type: 'Polygon', coordinates: polygon }));
+            case 'MultiLineString':
+                return geometry.coordinates.map((line) => ({ type: 'LineString', coordinates: line }));
+            case 'GeometryCollection':
+                return geometry.geometries.flatMap((part) => GeoGeometry.parts(part));
+            default:
+                return [geometry];
+        }
+    }
+    /** One centroid per disjoint part, so a feature whose parts lie far apart matches a hover over any of them. */
+    static partCentroids(geometry) {
+        return GeoGeometry.parts(geometry).map((part) => GeoGeometry.centroid(part));
+    }
+    /** The geometry without the parts `keep` rejects, or `null` when none stays. The same geometry when all do. */
+    static filterParts(geometry, keep) {
+        const parts = GeoGeometry.parts(geometry);
+        const kept = parts.filter((part) => keep({ centroid: GeoGeometry.centroid(part), geometry: part }));
+        if (kept.length === parts.length)
+            return geometry;
+        if (kept.length === 0)
+            return null;
+        if (parts.length === 1)
+            return kept[0];
+        switch (geometry.type) {
+            case 'MultiPolygon':
+                return {
+                    type: 'MultiPolygon',
+                    coordinates: kept.map((part) => part.coordinates)
+                };
+            case 'MultiLineString':
+                return {
+                    type: 'MultiLineString',
+                    coordinates: kept.map((part) => part.coordinates)
+                };
+            case 'GeometryCollection':
+                return { type: 'GeometryCollection', geometries: kept };
+            default:
+                return geometry;
+        }
+    }
+    /** The path between two points that changes longitude and latitude at a steady rate, the short way around: it keeps near its parallels where a great circle bends toward a pole. */
+    static parallelPath(from, to, steps = 64) {
+        const shift = ((((to[0] - from[0] + 180) % 360) + 360) % 360) - 180;
+        return Array.from({ length: steps + 1 }, (_, index) => {
+            const fraction = index / steps;
+            const lon = ((((from[0] + shift * fraction + 180) % 360) + 360) % 360) - 180;
+            return [lon, from[1] + (to[1] - from[1]) * fraction];
+        });
+    }
+    /**
+     * The great-circle arc between two points, as `steps + 1` points. Drawn
+     * through `Geo` because svelteplot's `Link` cannot read `x1`/`y1`/`x2`/`y2`
+     * under a projection (0.14.2).
+     */
+    static greatCircle(from, to, steps = 64) {
+        const [lambda1, phi1] = [GeoGeometry.#radians(from[0]), GeoGeometry.#radians(from[1])];
+        const [lambda2, phi2] = [GeoGeometry.#radians(to[0]), GeoGeometry.#radians(to[1])];
+        const distance = 2 *
+            Math.asin(Math.sqrt(Math.sin((phi2 - phi1) / 2) ** 2 +
+                Math.cos(phi1) * Math.cos(phi2) * Math.sin((lambda2 - lambda1) / 2) ** 2));
+        if (!Number.isFinite(distance) || distance === 0)
+            return [from, to];
+        return Array.from({ length: steps + 1 }, (_, index) => {
+            const fraction = index / steps;
+            const a = Math.sin((1 - fraction) * distance) / Math.sin(distance);
+            const b = Math.sin(fraction * distance) / Math.sin(distance);
+            const x = a * Math.cos(phi1) * Math.cos(lambda1) + b * Math.cos(phi2) * Math.cos(lambda2);
+            const y = a * Math.cos(phi1) * Math.sin(lambda1) + b * Math.cos(phi2) * Math.sin(lambda2);
+            const z = a * Math.sin(phi1) + b * Math.sin(phi2);
+            return [
+                GeoGeometry.#degrees(Math.atan2(y, x)),
+                GeoGeometry.#degrees(Math.atan2(z, Math.sqrt(x * x + y * y)))
+            ];
+        });
+    }
+    static #radians(degrees) {
+        return (degrees * Math.PI) / 180;
+    }
+    static #degrees(radians) {
+        return (radians * 180) / Math.PI;
+    }
+    static #extent(coords) {
+        let [minLon, minLat, maxLon, maxLat] = [Infinity, Infinity, -Infinity, -Infinity];
+        for (const [lon, lat] of coords) {
+            if (lon < minLon)
+                minLon = lon;
+            if (lon > maxLon)
+                maxLon = lon;
+            if (lat < minLat)
+                minLat = lat;
+            if (lat > maxLat)
+                maxLat = lat;
+        }
+        return [minLon, minLat, maxLon, maxLat];
+    }
+    static #coordinates(geometry, out = []) {
+        switch (geometry.type) {
+            case 'Point':
+                out.push(geometry.coordinates);
+                break;
+            case 'MultiPoint':
+            case 'LineString':
+                out.push(...geometry.coordinates);
+                break;
+            case 'MultiLineString':
+            case 'Polygon':
+                for (const line of geometry.coordinates)
+                    out.push(...line);
+                break;
+            case 'MultiPolygon':
+                for (const polygon of geometry.coordinates) {
+                    for (const ring of polygon)
+                        out.push(...ring);
+                }
+                break;
+            case 'GeometryCollection':
+                for (const part of geometry.geometries)
+                    GeoGeometry.#coordinates(part, out);
+                break;
+        }
+        return out;
+    }
+}

package/dist/plots/map/geo/GeoSegments.d.ts

@@ -0,0 +1,16 @@
+import type { ChannelScalesConfig } from '../../../types/layout/scales';
+import type { Segment } from '../../../types/plots/segments/config';
+import type { SegmentsConfig } from '../../../types/plots/props';
+/**
+ * The segments that apply to one geo feature. A feature is atomic, so a segment's
+ * `areas` do not apply: every entry is a plain patch, merged in order.
+ */
+export declare class GeoSegments {
+    #private;
+    /** The feature's entries, least specific first: `default`, its grouping bucket, then itself. */
+    static forFeature<TStyle>(segments: SegmentsConfig<TStyle>, featureId: string, groupingValue?: string): Segment<TStyle>[];
+    /** Every matching entry's `styles` merged field by field, the most specific winning. */
+    static style<TStyle extends object>(segments: SegmentsConfig<TStyle>, featureId: string, groupingValue?: string): TStyle;
+    /** The `scales` of the most specific matching entry that sets one: a ramp config does not merge key by key. */
+    static scales<TStyle>(segments: SegmentsConfig<TStyle>, featureId: string, groupingValue?: string): ChannelScalesConfig | undefined;
+}

package/dist/plots/map/geo/GeoSegments.js

@@ -0,0 +1,23 @@
+/**
+ * The segments that apply to one geo feature. A feature is atomic, so a segment's
+ * `areas` do not apply: every entry is a plain patch, merged in order.
+ */
+export class GeoSegments {
+    static #DEFAULT_KEY = 'default';
+    /** The feature's entries, least specific first: `default`, its grouping bucket, then itself. */
+    static forFeature(segments, featureId, groupingValue) {
+        return [
+            ...(segments[GeoSegments.#DEFAULT_KEY] ?? []),
+            ...(groupingValue ? (segments[groupingValue] ?? []) : []),
+            ...(segments[featureId] ?? [])
+        ];
+    }
+    /** Every matching entry's `styles` merged field by field, the most specific winning. */
+    static style(segments, featureId, groupingValue) {
+        return GeoSegments.forFeature(segments, featureId, groupingValue).reduce((merged, segment) => ({ ...merged, ...(segment.styles ?? {}) }), {});
+    }
+    /** The `scales` of the most specific matching entry that sets one: a ramp config does not merge key by key. */
+    static scales(segments, featureId, groupingValue) {
+        return GeoSegments.forFeature(segments, featureId, groupingValue).reduce((found, segment) => segment.scales ?? found, undefined);
+    }
+}

package/dist/plots/{geo → map/geo}/Plot.svelte

@@ -1,16 +1,16 @@
 <script lang="ts" generics="TProps extends Record<string, unknown>">
 	import Core from './Core.svelte';
-	import Plot from '../../layout/plot/Plot.svelte';
-	import { merge } from '../../utils/merge';
+	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';
+	import { GeoFeatures } from './GeoFeatures.svelte';
+	import type { GeoPlotProps, GeoPlotCoreProps } from '../../../types/plots/map/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>;
 
@@ -40,7 +40,7 @@
 
 	const sliced = $derived(timeline != null || facet != null);
 	// Only resolved here when slicing; otherwise the core resolves `data` itself.
-	const resolved = createGeoFeatures<TProps>(
+	const resolved = new GeoFeatures<TProps>(
 		() => (sliced ? core.data : []),
 		() => core.object
 	);

package/dist/plots/{geo → map/geo}/Plot.svelte.d.ts

@@ -1,5 +1,5 @@
-import Plot from '../../layout/plot/Plot.svelte';
-import type { GeoPlotProps } from '../../types/plots/geo/props';
+import Plot from '../../../layout/plot/Plot.svelte';
+import type { GeoPlotProps } from '../../../types/plots/map/geo/props';
 declare function $$render<TProps extends Record<string, unknown>>(): {
     props: GeoPlotProps<TProps>;
     exports: {};

package/dist/plots/{geo → map/geo}/defaults.d.ts

@@ -1,4 +1,4 @@
-import type { GeoPlotState, GeoPlotCtx } from '../../types/plots/geo/state';
-import { Pipeline } from '../../phases/Pipeline';
+import type { GeoPlotState, GeoPlotCtx } from '../../../types/plots/map/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 → map/geo}/defaults.js

@@ -3,7 +3,7 @@ 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';
+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([

package/dist/plots/{geo → map/geo}/phases/data.d.ts

@@ -1,4 +1,4 @@
-import type { GeoPlotState } from '../../../types/plots/geo/state';
+import type { GeoPlotState } from '../../../../types/plots/map/geo/state';
 /**
  * GeoPlot's "data" phase: every feature tagged with its resolved id/centroid,
  * then reduced by `excludeParts`. Reads no ctx.

package/dist/plots/{geo → map/geo}/phases/data.js

@@ -1,5 +1,6 @@
-import { resolveAccessor } from '../../utils/accessors';
-import { geometryCentroid, filterGeometryParts, defaultFeatureId } from '../../utils/geoAccessors';
+import { resolveAccessor } from '../../../../utils/accessors';
+import { GeoGeometry } from '../GeoGeometry';
+import { GeoFeatures } from '../GeoFeatures.svelte';
 /**
  * GeoPlot's "data" phase: every feature tagged with its resolved id/centroid,
  * then reduced by `excludeParts`. Reads no ctx.
@@ -8,18 +9,18 @@ export function buildData(state) {
     const { rawFeatures, featureId, excludeParts } = state;
     const getFeatureId = featureId
         ? resolveAccessor(featureId)
-        : defaultFeatureId;
+        : GeoFeatures.defaultId;
     const allFeatures = rawFeatures.map((f) => {
-        const [cx, cy] = geometryCentroid(f.geometry);
+        const [cx, cy] = GeoGeometry.centroid(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));
+            const geometry = GeoGeometry.filterParts(f.geometry, (part) => !excludeParts(part, f));
             if (!geometry)
                 return [];
-            const [cx, cy] = geometryCentroid(geometry);
+            const [cx, cy] = GeoGeometry.centroid(geometry);
             return [{ ...f, geometry, __cx: cx, __cy: cy }];
         });
     return { ...state, allFeatures, features };

package/dist/plots/{geo → map/geo}/phases/hover.d.ts

@@ -1,4 +1,4 @@
-import type { GeoPlotState, GeoPlotCtx } from '../../../types/plots/geo/state';
+import type { GeoPlotState, GeoPlotCtx } from '../../../../types/plots/map/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;
 /**

package/dist/plots/{geo → map/geo}/phases/hover.js

@@ -1,4 +1,5 @@
-import { HoverPhase } from '../../../phases/hover/HoverPhase';
+import { LegendState } from '../../../../layout/legend/LegendState.svelte';
+import { HoverSettings } from '../../../../layout/hover/HoverSettings';
 /** 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;
@@ -14,10 +15,10 @@ export function buildHover(state, ctx) {
     const features = state.features;
     const label = (f) => f.__id;
     const points = features
-        .filter((f) => !range || !color || HoverPhase.inRange(color(f), range))
+        .filter((f) => !range || !color || LegendState.inRange(color(f), range))
         .map((f) => ({ x: f.__cx, y: f.__cy, row: f, label: label(f) }));
     const hover = {
-        ...HoverPhase.buildHoverConfig({
+        ...HoverSettings.buildConfig({
             tooltip: tooltip,
             format: state.tooltipFormat,
             markers: authoredMarkers,
@@ -27,8 +28,7 @@ export function buildHover(state, ctx) {
             // 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.
+        // A map has no axes for a crosshair: 'punctual' only means an exact match.
         strategy: 'punctual',
         crosshair: false,
         exclude: isOverInset

package/dist/plots/{geo → map/geo}/phases/markers.d.ts

@@ -1,4 +1,4 @@
-import type { GeoPlotState, GeoPlotCtx } from '../../../types/plots/geo/state';
+import type { GeoPlotState, GeoPlotCtx } from '../../../../types/plots/map/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

package/dist/plots/{geo → map/geo}/phases/markers.js

@@ -1,6 +1,7 @@
-import { HoverPhase } from '../../../phases/hover/HoverPhase';
-import { resolveFeatureStyle } from '../../utils/geoSegments';
-import { DisabledStyle } from '../../../layout/legend/DisabledStyle';
+import { LegendState } from '../../../../layout/legend/LegendState.svelte';
+import { GeoSegments } from '../GeoSegments';
+import { MarkerChannels } from '../../../../markers/utils/MarkerChannels';
+import { DisabledStyle } from '../../../../layout/legend/DisabledStyle';
 /**
  * `graticule`/`sphere`/`contour` opt into drawing underneath the base map's
  * own fill/stroke instead of on top of it - see each config's own `behind`
@@ -24,13 +25,12 @@ export function buildMarkers(state, ctx) {
     function rangeFilteredStyle(base, f) {
         if (range == null || !color)
             return base;
-        const v = color(f);
-        if (v == null || (v >= range.min && v <= range.max))
+        if (LegendState.inRange(color(f), range))
             return base;
         return { ...base, ...DisabledStyle.fill(range.disabledStyle) };
     }
     function getFeatureStyle(f) {
-        return rangeFilteredStyle(resolveFeatureStyle(segments, f.__id, grouping?.(f)), f);
+        return rangeFilteredStyle(GeoSegments.style(segments, f.__id, grouping?.(f)), f);
     }
     const groups = new Map();
     for (const f of features) {
@@ -51,7 +51,7 @@ export function buildMarkers(state, ctx) {
     }
     // What the pointer can match: the features inside the legend's range, by id.
     const hoverable = new Map(features
-        .filter((f) => !range || !color || HoverPhase.inRange(color(f), range))
+        .filter((f) => !range || !color || LegendState.inRange(color(f), range))
         .map((f) => [f.__id, f]));
     const featureMarkers = styleGroups.map((group) => ({
         type: 'geo',
@@ -66,11 +66,6 @@ export function buildMarkers(state, ctx) {
     const behindMarkers = authoredMarkers.filter(isBehindMarker);
     const frontMarkers = authoredMarkers.filter((m) => !isBehindMarker(m) && m.type !== 'geo-hover');
     const hoverMarker = authoredMarkers.find((m) => m.type === 'geo-hover');
-    const markers = [
-        ...behindMarkers,
-        ...featureMarkers,
-        ...frontMarkers,
-        ...(hoverMarker ? [hoverMarker] : [])
-    ];
+    const markers = MarkerChannels.inheritAll([...behindMarkers, ...featureMarkers, ...frontMarkers, ...(hoverMarker ? [hoverMarker] : [])], state.scales);
     return { ...state, markers, styleGroups };
 }

package/dist/plots/{geo → map/geo}/phases/scales.d.ts

@@ -1,9 +1,9 @@
-import type { GeoPlotState, GeoPlotCtx } from '../../../types/plots/geo/state';
+import type { GeoPlotState, GeoPlotCtx } from '../../../../types/plots/map/geo/state';
 /**
  * GeoPlot's "scales" phase: each feature's own resolved color (mirrors
  * HeatmapPlot's own), with a per-feature override for whichever segment
  * (its `grouping` bucket, or itself by id) sets its own `scales.color` -
- * see `resolveFeatureScales`. A segment ramp's domain is built from just
+ * see `GeoSegments.scales`. A segment ramp's domain is built from just
  * the features that share its own key, so e.g. two grouping buckets each
  * get a ramp scaled to their own value range, not the whole dataset's.
  */