@fundar/data-chart-telling 1.1.0 → 1.2.0

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,5 +1,5 @@
-import { LegendState } from '../../../layout/legend/LegendState.svelte';
-import { HoverSettings } from '../../../layout/hover/HoverSettings';
+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;

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 { LegendState } from '../../../layout/legend/LegendState.svelte';
-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`
@@ -29,7 +30,7 @@ export function buildMarkers(state, ctx) {
         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) {
@@ -65,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.
  */

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

@@ -1,12 +1,12 @@
-import { resolveColorScale } from '../../../utils/color';
-import { resolveOpacityScale } from '../../../utils/opacity';
-import { ContinuousDomain } from '../../../utils/ContinuousDomain';
-import { resolveFeatureScales } from '../../utils/geoSegments';
+import { ColorRamp } from '../../../../utils/color';
+import { OpacityScale } from '../../../../utils/OpacityScale';
+import { ContinuousDomain } from '../../../../utils/ContinuousDomain';
+import { GeoSegments } from '../GeoSegments';
 /**
  * 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.
  */
@@ -19,14 +19,12 @@ export function buildScales(state, ctx) {
     const valueDomain = ContinuousDomain.build(scales.color?.domain, colorValues);
     const effectiveDomain = valueDomain ? ContinuousDomain.ramp(valueDomain, range) : null;
     const colorScale = effectiveDomain
-        ? resolveColorScale({ ...scales.color, domain: effectiveDomain }, effectiveDomain, [
-            cfg.continuous.min,
-            cfg.continuous.max
-        ])
+        ? ColorRamp.continuous(cfg, scales.color, effectiveDomain)
         : null;
     // Per-segment-key ramp cache - built lazily, once per distinct grouping
     // value/feature id that actually has its own `scales.color`.
     const segmentScaleCache = new Map();
+    const colorRamps = [];
     function segmentColorScaleFor(key, segScales) {
         if (segmentScaleCache.has(key))
             return segmentScaleCache.get(key);
@@ -35,9 +33,16 @@ export function buildScales(state, ctx) {
             : features.filter((g) => g.__id === key);
         const vals = peers.map((g) => color?.(g)).filter((v) => v != null);
         const scale = vals.length
-            ? resolveColorScale({ ...segScales?.color, domain: [Math.min(...vals), Math.max(...vals)] }, [Math.min(...vals), Math.max(...vals)], [cfg.continuous.min, cfg.continuous.max])
+            ? ColorRamp.continuous(cfg, segScales?.color, [Math.min(...vals), Math.max(...vals)])
             : null;
         segmentScaleCache.set(key, scale);
+        if (vals.length && segScales?.color) {
+            colorRamps.push({
+                name: key,
+                domain: [Math.min(...vals), Math.max(...vals)],
+                scale: segScales.color
+            });
+        }
         return scale;
     }
     const resolveColor = colorScale
@@ -47,7 +52,7 @@ export function buildScales(state, ctx) {
                 return undefined;
             const groupingValue = grouping?.(f);
             const featureId = f.__id ?? '';
-            const segScales = resolveFeatureScales(segments, featureId, groupingValue);
+            const segScales = GeoSegments.scales(segments, featureId, groupingValue);
             if (segScales?.color) {
                 const scale = segmentColorScaleFor(groupingValue ?? featureId, segScales);
                 if (scale)
@@ -56,6 +61,16 @@ export function buildScales(state, ctx) {
             return colorScale ? colorScale(v) : undefined;
         }
         : undefined;
+    // Every segment ramp is built up front, so the legend can draw each one.
+    if (colorScale) {
+        for (const f of features) {
+            const featureId = f.__id ?? '';
+            const groupingValue = grouping?.(f);
+            const segScales = GeoSegments.scales(segments, featureId, groupingValue);
+            if (segScales?.color)
+                segmentColorScaleFor(groupingValue ?? featureId, segScales);
+        }
+    }
     // Plot-level only - no segment-scoped opacity ramp (unlike `resolveColor`
     // above), since there's no concrete use case yet driving that complexity.
     const opacityDomain = (() => {
@@ -65,7 +80,7 @@ export function buildScales(state, ctx) {
         return vals.length ? [Math.min(...vals), Math.max(...vals)] : null;
     })();
     const opacityScale = opacityDomain
-        ? resolveOpacityScale(scales.opacity, opacityDomain, cfg.continuous.opacityRange)
+        ? OpacityScale.resolve(scales.opacity, opacityDomain, cfg.continuous.opacityRange)
         : null;
     const resolveOpacity = opacityScale
         ? (f) => {
@@ -76,6 +91,7 @@ export function buildScales(state, ctx) {
     return {
         ...state,
         colorDomain: valueDomain ?? undefined,
+        colorRamps: colorRamps.length ? colorRamps : undefined,
         opacityDomain: opacityDomain && typeof opacityDomain[0] === 'number'
             ? opacityDomain
             : undefined,

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

@@ -1,3 +1,3 @@
-import type { GeoPlotState } from '../../../types/plots/geo/state';
+import type { GeoPlotState } from '../../../../types/plots/map/geo/state';
 /** GeoPlot's "tooltip" phase: a hovered feature reads as its id. */
 export declare function buildTooltip<TProps extends Record<string, unknown>>(state: GeoPlotState<TProps>): GeoPlotState<TProps>;

package/dist/plots/map/geo/phases/tooltip.js

@@ -0,0 +1,5 @@
+import { GeoFeatures } from '../GeoFeatures.svelte';
+/** GeoPlot's "tooltip" phase: a hovered feature reads as its id. */
+export function buildTooltip(state) {
+    return { ...state, tooltipFormat: (f) => GeoFeatures.defaultId(f) };
+}

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

@@ -1,5 +1,5 @@
-import type { FacetConfig } from '../../types/layout/facet';
-import type { TimelineConfig } from '../../types/layout/timeline';
+import type { FacetConfig } from '../../../types/layout/facet';
+import type { TimelineConfig } from '../../../types/layout/timeline';
 type Row = Record<string, unknown>;
 /**
  * What a GeoPlot hands `Plot` to slice by: one stand-in row per value

package/dist/plots/{geo → map/geo}/slices.js

@@ -1,5 +1,5 @@
-import { TimelineTime } from '../../layout/timeline/TimelineTime';
-import { isFacetWrap } from '../../layout/facet/config';
+import { TimelineTime } from '../../../layout/timeline/TimelineTime';
+import { isFacetWrap } from '../../../layout/facet/config';
 const SLICE = Symbol('dct-geo-slice');
 /** A slicing field's value on a feature (from its `properties`) or on a marker's own row. */
 function readField(field, row) {

package/dist/plots/{bar → ranking/bar}/Plot.svelte

@@ -1,7 +1,7 @@
 <script lang="ts" generics="TData extends Record<string, unknown>">
-	import Plot from '../../layout/plot/Plot.svelte';
+	import Plot from '../../../layout/plot/Plot.svelte';
 	import { buildBarDefaults } from './defaults';
-	import type { BarPlotProps, BarPlotCoreProps } from '../../types/plots/bar/props';
+	import type { BarPlotProps, BarPlotCoreProps } from '../../../types/plots/ranking/bar/props';
 
 	/**
 	 * A bar plot: vertical when its categories run along `x`, horizontal when they run along `y` (the value then on `x`, as in svelteplot's `BarX`). Draws from pre-built `series` or flat `data` rows.