@fundar/data-chart-telling 1.18.0 → 1.20.0

package/dist/plots/evolution/line/defaults.js

@@ -22,15 +22,13 @@ export function buildLineDefaults() {
         transforms: { labels: { select: 'last', skip: ValueLabels.skipGaps } },
         styles: {
             values: {
-                anchor: 'start',
+                layout: 'point',
+                layouts: { point: { side: 'after' }, path: { side: 'above', offset: 'end' } },
                 format: (v, number, context) => `${context.series} - ${number(v)}`,
-                reach: (labels, state) => labels.reachAtSeriesEnds(state)
+                reach: (labels, state) => (labels.layout === 'point' ? labels.reachAtSeriesEnds(state) : [])
             }
         },
-        markers: {
-            marks: buildMarks,
-            valueLabels: (labels, state) => labels.atSeriesEnds(state)
-        },
+        markers: { marks: buildMarks },
         timeline: { filterMode: 'upTo', interpolation: { value: 'y', key: ['grouping'] } }
     };
 }

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

@@ -1,3 +1,4 @@
+import { ValueLabels } from '../../../layout/styles/ValueLabels';
 import { getConfiguration } from '../../../configuration/config.svelte';
 import { resolveGapRuns, resolveGapsForSeries } from '../../utils/gaps';
 /**
@@ -197,5 +198,6 @@ export function buildMarks(state, env) {
         disabledStrokeFor,
         disabledDotsFor
     });
-    return [...lineMarkers, ...gapMarkers];
+    const labels = state.valueLabels?.show ? state.valueLabels.forSeries(state, env) : undefined;
+    return [...ValueLabels.onMarkers(lineMarkers, 'line', labels), ...gapMarkers];
 }

package/dist/plots/evolution/slope/Plot.svelte

@@ -1,5 +1,5 @@
 <script lang="ts" generics="TData extends Record<string, unknown>">
-	import Plot from '../../../layout/plot/Plot.svelte';
+	import AbstractPlot from '../../../layout/plot/AbstractPlot.svelte';
 	import { buildSlopeDefaults } from './defaults';
 	import type { SlopePlotProps, SlopePlotCoreProps } from '../../../types/plots/evolution/slope/props';
 
@@ -25,7 +25,7 @@
 	}: SlopePlotProps<TData> = $props();
 </script>
 
-<Plot
+<AbstractPlot
 	core={core as SlopePlotCoreProps<TData>}
 	defaults={buildSlopeDefaults}
 	bind:margins

package/dist/plots/evolution/slope/Plot.svelte.d.ts

@@ -1,4 +1,3 @@
-import Plot from '../../../layout/plot/Plot.svelte';
 import type { SlopePlotProps } from '../../../types/plots/evolution/slope/props';
 declare function $$render<TData extends Record<string, unknown>>(): {
     props: SlopePlotProps<TData>;

package/dist/plots/evolution/slope/defaults.js

@@ -1,4 +1,4 @@
-import { buildMarks, buildValueLabels } from './markers';
+import { buildMarks } from './markers';
 import { PlotAxes } from '../../../phases/data/PlotAxes';
 import { HoverDefaults } from '../../../layout/hover/HoverDefaults';
 import { ValueLabels } from '../../../layout/styles/ValueLabels';
@@ -24,11 +24,12 @@ export function buildSlopeDefaults() {
         },
         styles: {
             values: {
-                anchor: 'start',
+                layout: 'point',
+                layouts: { point: { side: 'after' }, path: { side: 'above', offset: 'middle' } },
                 format: (v, number, context) => `${context.series} - ${number(v)}`
             }
         },
-        markers: { marks: buildMarks, valueLabels: buildValueLabels },
+        markers: { marks: buildMarks },
         // Only two positions: a rule along the value axis at the hovered point says more than one across them.
         hover: { ...line.hover, marker: (state) => HoverDefaults.valueRule(PlotAxes.valueOf(state)) }
     };

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

@@ -1,6 +1,7 @@
-import type { ValueLabels } from '../../../layout/styles/ValueLabels';
+import { ValueLabels } from '../../../layout/styles/ValueLabels';
 import type { EdgeBox } from '../../../types/layout/box';
-import type { AxisBasedMarkersConfig, TextMarkerConfig } from '../../../types/markers/common';
+import type { AxisBasedMarkersConfig } from '../../../types/markers/common';
+import type { MarkerLabelConfig } from '../../../types/markers/labels/common';
 import type { SlopePlotState, SlopePlotEnv } from '../../../types/plots/evolution/slope/state';
 /**
  * SlopePlot's "markers" phase: each series' line, with a dot on every point
@@ -11,6 +12,6 @@ export declare function buildMarks<TData extends Record<string, unknown>>(state:
  * SlopePlot's value labels: the series' first points labelled before them and
  * its last ones after, each end spread apart where its labels would overlap.
  */
-export declare function buildValueLabels<TData extends Record<string, unknown>>(labels: ValueLabels, state: SlopePlotState<TData>): TextMarkerConfig[];
+export declare function buildValueLabels<TData extends Record<string, unknown>>(labels: ValueLabels, state: SlopePlotState<TData>, env: SlopePlotEnv): MarkerLabelConfig[];
 /** Where SlopePlot's labels are expected to sit: past the points at both ends. */
 export declare function buildReach<TData extends Record<string, unknown>>(labels: ValueLabels, state: SlopePlotState<TData>): EdgeBox[];

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

@@ -1,9 +1,10 @@
 import { getConfiguration } from '../../../configuration/config.svelte';
 import { buildLineMarkers } from '../line/markers';
 import { ProcessedPositions } from '../../../phases/transforms/ProcessedPositions';
-/** The anchor of the labels at the plot's start: the mirror of the end's, so `'start'` always reads outward. */
-function startAnchor(anchor) {
-    return anchor === 'start' ? 'end' : anchor === 'end' ? 'start' : anchor;
+import { ValueLabels } from '../../../layout/styles/ValueLabels';
+/** The side of the labels at the plot's start: the mirror of the end's, so `'after'` always reads outward. */
+function startSide(side) {
+    return side === 'after' ? 'before' : side === 'before' ? 'after' : side;
 }
 /** The value a position is told apart by: a date by its time. */
 const keyOf = (value) => (value instanceof Date ? value.getTime() : value);
@@ -24,13 +25,17 @@ export function buildMarks(state, env) {
             }
         }))
     }));
-    return buildLineMarkers({
+    const lines = buildLineMarkers({
         groupedSeries: groups,
         colorFor: state.colorForSeries,
         disabledStrokeFor: (name) => env.interaction?.strokeFor(name),
         disabledDotsFor: (name) => env.interaction?.dotsFor(name),
         curve: state.styles?.curve
     });
+    const labels = state.valueLabels?.show
+        ? buildValueLabels(state.valueLabels, state, env)
+        : undefined;
+    return ValueLabels.onMarkers(lines, 'line', labels);
 }
 /** The rows labelled at the plot's first position and at its last, each series' own. */
 function labelledEnds(state) {
@@ -52,25 +57,27 @@ function labelledEnds(state) {
  * SlopePlot's value labels: the series' first points labelled before them and
  * its last ones after, each end spread apart where its labels would overlap.
  */
-export function buildValueLabels(labels, state) {
+export function buildValueLabels(labels, state, env) {
     if (!state.processedData)
         return [];
+    if (labels.layout === 'path')
+        return labels.alongSeries(state, env);
     const { start, end } = labelledEnds(state);
     return [
-        ...labels.atSeriesEnds(state, {
+        ...labels.atSeriesEnds(state, env, {
             rows: start,
-            anchor: startAnchor(labels.anchor),
+            side: startSide(labels.side),
             lane: true,
             flip: false
         }),
-        ...labels.atSeriesEnds(state, { rows: end, lane: true })
+        ...labels.atSeriesEnds(state, env, { rows: end, lane: true })
     ];
 }
 /** Where SlopePlot's labels are expected to sit: past the points at both ends. */
 export function buildReach(labels, state) {
     // Labels before the first position reach the left edge, those after the last one the right.
     const before = labels
-        .reachAtSeriesEnds(state, startAnchor(labels.anchor))
+        .reachAtSeriesEnds(state, startSide(labels.side))
         .map(({ box, edges }) => ({ box, edges: edges.filter((edge) => edge !== 'right') }));
     const after = labels
         .reachAtSeriesEnds(state)

package/dist/plots/evolution/sparkline/Plot.svelte

@@ -1,5 +1,5 @@
 <script lang="ts" generics="TData extends Record<string, unknown>">
-	import Plot from '../../../layout/plot/Plot.svelte';
+	import AbstractPlot from '../../../layout/plot/AbstractPlot.svelte';
 	import { buildSparklineDefaults } from './defaults';
 	import type {
 		SparklinePlotProps,
@@ -28,7 +28,7 @@
 	}: SparklinePlotProps<TData> = $props();
 </script>
 
-<Plot
+<AbstractPlot
 	core={core as SparklinePlotCoreProps<TData>}
 	defaults={buildSparklineDefaults}
 	bind:margins

package/dist/plots/evolution/sparkline/Plot.svelte.d.ts

@@ -1,4 +1,3 @@
-import Plot from '../../../layout/plot/Plot.svelte';
 import type { SparklinePlotProps } from '../../../types/plots/evolution/sparkline/props';
 declare function $$render<TData extends Record<string, unknown>>(): {
     props: SparklinePlotProps<TData>;

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

@@ -19,7 +19,7 @@ export function buildSparklineDefaults() {
                 format: (value, number) => number(value)
             }
         },
-        markers: { marks: buildMarks, valueLabels: line.markers.valueLabels },
+        markers: { marks: buildMarks },
         // Small and bare: a dot on the hovered point, and nothing else.
         hover: { ...line.hover, marker: () => ({ back: [], front: [HoverDefaults.dot()] }) }
     };

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

@@ -1,3 +1,4 @@
+import { ValueLabels } from '../../../layout/styles/ValueLabels';
 import { getConfiguration } from '../../../configuration/config.svelte';
 import { buildLineMarkers } from '../line/markers';
 import { resolveAccessor } from '../../../utils/accessors';
@@ -52,5 +53,6 @@ export function buildMarks(state, env) {
             }
         ];
     });
-    return [...lines, ...dots];
+    const labels = state.valueLabels?.show ? state.valueLabels.forSeries(state, env) : undefined;
+    return [...ValueLabels.onMarkers(lines, 'line', labels), ...dots];
 }

package/dist/plots/generic/Plot.svelte

@@ -0,0 +1,42 @@
+<script lang="ts" generics="TData extends Record<string, unknown>">
+	import AbstractPlot from '../../layout/plot/AbstractPlot.svelte';
+	import { buildGenericDefaults } from './defaults';
+	import type { GenericPlotProps, GenericPlotCoreProps } from '../../types/plots/generic/props';
+
+	/**
+	 * A plot of no kind: no shapes or defaults of its own, only its `markers`. `data` and the channels
+	 * are optional; markers without their own take them, and its `segments`, `transforms`, `styles`,
+	 * chrome, `timeline` and `facet` work as on any plot.
+	 * `margins` is bindable: it reports the margin the plot settled on.
+	 */
+	let {
+		title,
+		subtitle,
+		caption,
+		header,
+		footer,
+		legend,
+		order,
+		timeline,
+		facet,
+		tooltip,
+		margins = $bindable(),
+		...core
+	}: GenericPlotProps<TData> = $props();
+</script>
+
+<AbstractPlot
+	core={core as GenericPlotCoreProps<TData>}
+	defaults={buildGenericDefaults}
+	bind:margins
+	{title}
+	{subtitle}
+	{caption}
+	{header}
+	{footer}
+	{legend}
+	{order}
+	{timeline}
+	{facet}
+	{tooltip}
+/>

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

@@ -0,0 +1,25 @@
+import type { GenericPlotProps } from '../../types/plots/generic/props';
+declare function $$render<TData extends Record<string, unknown>>(): {
+    props: GenericPlotProps<TData>;
+    exports: {};
+    bindings: "margins";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<TData extends Record<string, unknown>> {
+    props(): ReturnType<typeof $$render<TData>>['props'];
+    events(): ReturnType<typeof $$render<TData>>['events'];
+    slots(): ReturnType<typeof $$render<TData>>['slots'];
+    bindings(): "margins";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TData extends Record<string, unknown>>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TData>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TData>['props']>, ReturnType<__sveltets_Render<TData>['events']>, ReturnType<__sveltets_Render<TData>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TData>['bindings']>;
+    } & ReturnType<__sveltets_Render<TData>['exports']>;
+    <TData extends Record<string, unknown>>(internal: unknown, props: ReturnType<__sveltets_Render<TData>['props']> & {}): ReturnType<__sveltets_Render<TData>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const Plot: $$IsomorphicComponent;
+type Plot<TData extends Record<string, unknown>> = InstanceType<typeof Plot<TData>>;
+export default Plot;

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

@@ -0,0 +1,4 @@
+import type { AxisPlotDefaults } from '../../types/phases';
+import type { GenericPlotState, GenericPlotEnv } from '../../types/plots/generic/state';
+/** The plot with no kind: it draws only its `markers`. */
+export declare function buildGenericDefaults<TData extends Record<string, unknown>>(): AxisPlotDefaults<GenericPlotState<TData>, GenericPlotEnv>;

package/dist/plots/generic/defaults.js

@@ -0,0 +1,7 @@
+/** The plot with no kind: it draws only its `markers`. */
+export function buildGenericDefaults() {
+    return {
+        data: { segments: { color: (style) => style?.fill } },
+        markers: { marks: () => [] }
+    };
+}

package/dist/plots/map/geo/Core.svelte

@@ -7,6 +7,7 @@
 	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 { GeoFeature } from '../../../types/plots/data/geo';
 	import type { GeoPlotState, GeoPlotEnv } from '../../../types/plots/map/geo/state';
 
 	/**
@@ -19,10 +20,10 @@
 	let {
 		data,
 		object,
-		featureId,
-		color,
-		grouping,
-		opacity,
+		featureId: featureIdProp,
+		color: colorProp,
+		grouping: groupingProp,
+		opacity: opacityProp,
 		excludeParts,
 		width,
 		height,
@@ -33,11 +34,26 @@
 		coordinates = {},
 		margins = $bindable(),
 		tooltip = undefined,
+		sliceContext = {},
 		pipeline
 	}: Props = $props();
 
 	const cfg = $derived(getConfiguration());
 
+	// The callbacks read a feature in the slice this core draws; the pipeline's phases call them with the feature alone.
+	const color = $derived(colorProp && ((f: GeoFeature<TProps>) => colorProp(f, sliceContext)));
+	const grouping = $derived(
+		groupingProp && ((f: GeoFeature<TProps>) => groupingProp(f, sliceContext))
+	);
+	const opacity = $derived(
+		opacityProp && ((f: GeoFeature<TProps>) => opacityProp(f, sliceContext))
+	);
+	const featureId = $derived(
+		typeof featureIdProp === 'function'
+			? (f: GeoFeature<TProps>) => featureIdProp(f, sliceContext)
+			: featureIdProp
+	);
+
 	// ── Resolve data: GeoJSON is synchronous, TopoJSON is converted async ────
 	const resolved = new GeoFeatures<TProps>(
 		() => data,
@@ -83,7 +99,7 @@
 		fillOpacity: styles.fillOpacity,
 		stroke: styles.stroke,
 		strokeWidth: styles.strokeWidth,
-		onFeatureClick: styles.onFeatureClick
+		onFeatureClick: styles.onFeatureClick && ((d, e) => styles.onFeatureClick!(d, e, sliceContext))
 	});
 	// The kind's pipeline, built once by its plot, over the state this core seeds.
 	const plotState = $derived(
@@ -98,6 +114,7 @@
 				segments,
 				scales,
 				authoredMarkers: markers,
+				slice: sliceContext,
 				tooltip,
 				width,
 				height,
@@ -130,7 +147,13 @@
 		markers: markersOut,
 		scales: layoutScales,
 		channels: {
-			color: { source: ChannelName.of(color, 'color') },
+			// Its own ramps draw every colored feature: the plot's has nothing to show.
+			color: {
+				source:
+					plotState.colorRamps && !plotState.colorDomain
+						? undefined
+						: ChannelName.of(color, 'color')
+			},
 			opacity: { source: ChannelName.of(opacity, 'opacity') }
 		},
 		colorDomain: plotState.colorDomain,

package/dist/plots/map/geo/Plot.svelte

@@ -1,9 +1,10 @@
 <script lang="ts" generics="TProps extends Record<string, unknown>">
 	import Core from './Core.svelte';
-	import Plot from '../../../layout/plot/Plot.svelte';
+	import AbstractPlot from '../../../layout/plot/AbstractPlot.svelte';
 	import { merge } from '../../../utils/merge';
 	import { buildGeoDefaults } from './defaults';
-	import { buildGeoSlicing } from './slices';
+	import { buildGeoSlicing, GeoSlices } from './slices';
+	import { Slice } from '../../../layout/plot/Slice';
 	import { GeoFeatures } from './GeoFeatures.svelte';
 	import type { GeoPlotProps, GeoPlotCoreProps } from '../../../types/plots/map/geo/props';
 	import type { GeoFeature } from '../../../types/plots/data/geo';
@@ -19,9 +20,11 @@
 	 * 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.
+	 * lacks the field draws in every slice, the color ramp spans every
+	 * slice, and the panels may come from `facet.values` alone (or `rowValues`, `colValues`,
+	 * `timeline.values`), one layer of features serving them all. The callbacks that read a
+	 * feature get the slice as their last argument (`GeoSliceContext`). With
+	 * `coordinates.projection.domain: 'data'`, each facet zooms to its own features.
 	 */
 	let {
 		title,
@@ -54,13 +57,29 @@
 		buildGeoSlicing({ rows: [...features, ...markerRows], timeline, facet })
 	);
 
-	/** The color ramp's domain over every feature, so each slice colors on the same scale. */
+	/**
+	 * The color ramp's domain over every feature as each slice reads it - a facet panel, a timeline step, each
+	 * with its own context - so every slice colors on the same scale. Not under `scales: 'free'` (the
+	 * facet's, or the timeline's when there is no facet): each slice then fits its own.
+	 */
 	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));
+		if ((facet ? facet.scales : timeline?.scales) === 'free') return undefined;
+		const all = resolved.features as GeoFeature<TProps>[];
+		const whole = new Slice({
+			rows: features,
+			timeline: slicing.timeline,
+			facet: slicing.facet,
+			filterMode: undefined
+		});
+		const reads = slicing.slices.length
+			? slicing.slices.flatMap(({ place, context }) => {
+					const keep = whole.keep(place) as unknown as (f: GeoFeature<TProps>) => boolean;
+					return all.filter(keep).map((f) => value(f, context));
+				})
+			: all.map((f) => value(f, {}));
+		const values = reads.filter((v): v is number => typeof v === 'number' && Number.isFinite(v));
 		return values.length
 			? { color: { domain: [Math.min(...values), Math.max(...values)] } }
 			: undefined;
@@ -69,8 +88,16 @@
 	/** 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;
+		const sliceContext = GeoSlices.contextOf(slice);
 		if (!sliced)
-			return { ...core, width: slice.width, height: slice.height, margins, tooltip: tip };
+			return {
+				...core,
+				width: slice.width,
+				height: slice.height,
+				margins,
+				tooltip: tip,
+				sliceContext
+			};
 		return {
 			...core,
 			data: features.filter(slice.keep) as unknown as GeoFeature<TProps>[],
@@ -82,12 +109,13 @@
 			height: slice.height,
 			margins: slice.margins ?? margins,
 			scales: merge(sharedColor, core.scales),
-			tooltip: tip
+			tooltip: tip,
+			sliceContext
 		} as GeoPlotCoreProps<TProps>;
 	}
 </script>
 
-<Plot
+<AbstractPlot
 	{Core}
 	core={core as GeoPlotCoreProps<TProps>}
 	defaults={buildGeoDefaults}

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

@@ -1,4 +1,3 @@
-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>;

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

@@ -1,6 +1,7 @@
 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 env.
+ * then reduced by `excludeParts`. Each carries the slice it is drawn in as its
+ * row context. Reads no env.
  */
 export declare function buildData<TProps extends Record<string, unknown>>(state: GeoPlotState<TProps>): GeoPlotState<TProps>;

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

@@ -1,12 +1,14 @@
 import { resolveAccessor } from '../../../../utils/accessors';
 import { GeoGeometry } from '../GeoGeometry';
 import { GeoFeatures } from '../GeoFeatures.svelte';
+import { ROW_CONTEXT_KEY } from '../../../../phases/context/rowContextKey';
 /**
  * GeoPlot's "data" phase: every feature tagged with its resolved id/centroid,
- * then reduced by `excludeParts`. Reads no env.
+ * then reduced by `excludeParts`. Each carries the slice it is drawn in as its
+ * row context. Reads no env.
  */
 export function buildData(state) {
-    const { rawFeatures, featureId, excludeParts } = state;
+    const { rawFeatures, featureId, excludeParts, slice = {} } = state;
     const getFeatureId = featureId
         ? resolveAccessor(featureId)
         : GeoFeatures.defaultId;
@@ -23,5 +25,9 @@ export function buildData(state) {
             const [cx, cy] = GeoGeometry.centroid(geometry);
             return [{ ...f, geometry, __cx: cx, __cy: cy }];
         });
+    // Kept as the row's context, which a copy of the feature carries along: a tooltip's `format` reads it back.
+    for (const f of new Set([...allFeatures, ...features])) {
+        f[ROW_CONTEXT_KEY] = slice;
+    }
     return { ...state, allFeatures, features };
 }

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

@@ -61,7 +61,9 @@ export function buildScales(state, env) {
             return colorScale ? colorScale(v) : undefined;
         }
         : undefined;
-    // Every segment ramp is built up front, so the legend can draw each one.
+    // Every segment ramp is built up front, so the legend can draw each one. The plot's own ramp is left out of
+    // the legend when every colored feature has one of its own: nothing is drawn with it.
+    let usesPlotRamp = false;
     if (colorScale) {
         for (const f of features) {
             const featureId = f.__id ?? '';
@@ -69,6 +71,8 @@ export function buildScales(state, env) {
             const segScales = GeoSegments.scales(segments, featureId, groupingValue);
             if (segScales?.color)
                 segmentColorScaleFor(groupingValue ?? featureId, segScales);
+            else if (color?.(f) != null)
+                usesPlotRamp = true;
         }
     }
     // Plot-level only - no segment-scoped opacity ramp (unlike `resolveColor`
@@ -90,7 +94,7 @@ export function buildScales(state, env) {
         : undefined;
     return {
         ...state,
-        colorDomain: valueDomain ?? undefined,
+        colorDomain: (usesPlotRamp || !colorRamps.length ? valueDomain : undefined) ?? undefined,
         colorRamps: colorRamps.length ? colorRamps : undefined,
         opacityDomain: opacityDomain && typeof opacityDomain[0] === 'number'
             ? opacityDomain

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

@@ -1,10 +1,22 @@
 import type { FacetConfig } from '../../../types/layout/facet';
-import type { TimelineConfig } from '../../../types/layout/timeline';
+import type { TimelineConfig, TimeValue } from '../../../types/layout/timeline';
+import type { SlicePlace } from '../../../types/layout/plot';
+import type { GeoSliceContext } from '../../../types/plots/data/geo';
 type Row = Record<string, unknown>;
+/** One slice of a sliced map: where it sits, and the context its features are read in. */
+export type GeoSlice = {
+    place: SlicePlace;
+    context: GeoSliceContext;
+};
 /**
  * What a GeoPlot hands `Plot` to slice by: one stand-in row per value
- * combination found in the features and markers' rows, and timeline/facet
- * accessors that read a stand-in or a real row.
+ * combination, and timeline/facet accessors that read a stand-in or a real
+ * row. A dimension's values are the ones the timeline or facet names
+ * (`timeline.values`, `facet.values`, `rowValues`, `colValues`), in
+ * their order, then any more found in the features and markers' rows - so
+ * the slices exist even when no feature carries the field. Each combination
+ * is also returned as a `slices` entry: its place and the context its
+ * features are read in.
  */
 export declare function buildGeoSlicing(args: {
     rows: Row[];
@@ -12,7 +24,19 @@ export declare function buildGeoSlicing(args: {
     facet?: FacetConfig<Row>;
 }): {
     rows: Row[];
+    slices: GeoSlice[];
     timeline?: TimelineConfig<Row>;
     facet?: FacetConfig<Row>;
 };
+export declare const GeoSlices: {
+    /** The context a callback reads a feature in, for the slice at `place`: empty when there is none. */
+    contextOf(place: {
+        time?: TimeValue;
+        facet?: {
+            facetValue: string;
+            row?: string;
+            col?: string;
+        };
+    }): GeoSliceContext;
+};
 export {};