@fundar/data-chart-telling 0.0.14 → 0.0.15

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

@@ -1,7 +1,11 @@
-import type { PlotProps } from '../../types/plots/props';
-import type { LineSegmentStyle } from '../../types/plots/styles';
+import type { BasePlotProps } from '../../types/plots/props';
+import type { SeriesProps, DataProps } from '../../types/plots/data/common';
+import type { AxisBasedScalesConfig } from '../../types/plots/props';
+import type { BasePlotStyles } from '../../types/plots/styles/common';
+import type { LineSegmentStyle } from '../../types/plots/segments/common';
+import type { Marker } from '../../types/markers/common';
 declare function $$render<TData extends Record<string, unknown>>(): {
-    props: PlotProps<TData, LineSegmentStyle>;
+    props: BasePlotProps<SeriesProps<TData> | DataProps<TData>, TData, BasePlotStyles, LineSegmentStyle, Marker, AxisBasedScalesConfig<TData>>;
     exports: {};
     bindings: "";
     slots: {};

package/dist/plots/pyramid/Plot.svelte

@@ -6,12 +6,20 @@
   import { paletteColor } from '../../utils/color';
   import { buildSeries } from '../../utils/grouping';
   import { buildGroupedSeries, validateSegments, resolveSegmentsForSeries, matchesSegmentX, getDataForSegments } from '../utils/segments';
-  import PlotLayout from '../../layout/plot/PlotLayout.svelte';
-  import HoverMarker from '../markers/HoverMarker.svelte';
-  import type { PlotProps } from '../../types/plots/props';
-  import type { Series, AxisValue } from '../../types/plots/common';
-  import type { BarSegmentStyle, ValueAnchor } from '../../types/plots/styles';
-  import type { Marker } from '../../types/plots/markers';
+  import BasePlotLayout from '../../layout/plot/BasePlotLayout.svelte';
+  import AxisLayout from '../../layout/plot/AxisLayout.svelte';
+  import GridLayout from '../../layout/plot/GridLayout.svelte';
+  import RuleLayout from '../../layout/plot/RuleLayout.svelte';
+  import HoverMarker from '../../markers/HoverMarker.svelte';
+  import { hasHoverMarker, resolveHoverStrategy, resolveHoverSync } from '../../layout/tooltip/utils';
+  import type { BasePlotProps } from '../../types/plots/props';
+  import type { AxisValue } from '../../types/plots/axis';
+  import type { Series, SeriesProps, DataProps } from '../../types/plots/data/common';
+  import type { AxisBasedScalesConfig } from '../../types/plots/props';
+  import type { BasePlotStyles } from '../../types/plots/styles/common';
+  import type { ValueAnchor } from '../../types/plots/constants';
+  import type { BarSegmentStyle } from '../../types/plots/segments/common';
+  import type { Marker } from '../../types/markers/common';
 
   /**
    * A population-pyramid-style diverging bar chart: each series is mirrored
@@ -29,6 +37,15 @@
   type PyramidSide = 'left' | 'right';
   type InternalSeries = Series<TData> & { side: PyramidSide };
 
+  type Props = BasePlotProps<
+    SeriesProps<TData> | DataProps<TData>,
+    TData,
+    BasePlotStyles,
+    BarSegmentStyle,
+    Marker,
+    AxisBasedScalesConfig<TData>
+  >;
+
   let {
     width,
     height,
@@ -43,7 +60,7 @@
     segments = {},
     markers = [],
     tooltip = undefined,
-  }: PlotProps<TData, BarSegmentStyle> = $props();
+  }: Props = $props();
 
   $effect(() => { validateSegments(segments); });
 
@@ -53,6 +70,10 @@
   const showVals = $derived(styles.values?.show ?? false);
   const fmtVal = $derived(styles.values?.format ?? ((v: number) => `${v}`));
   const valAnchor = $derived<ValueAnchor>(styles.values?.anchor ?? 'outside');
+  // 'outside' is a per-point escape hatch resolved by HoverMarker; pyramid's
+  // own value labels already have their own `anchor: 'outside'` concept
+  // above, so treat it as unset here.
+  const resolvedTextAnchor = $derived(styles.values?.textAnchor === 'outside' ? undefined : styles.values?.textAnchor);
 
   // Sort series names alphabetically; even index → left, odd → right.
   // scales.z.reverse flips the assignment so the second name goes left.
@@ -68,7 +89,9 @@
   });
 
   const groupedSeries = $derived(
-    buildGroupedSeries<InternalSeries, BarSegmentStyle>(resolvedSeries, segments),
+    // connect: false — bars are discrete; there's no visual gap between
+    // adjacent categories to bridge (see buildGroupedSeries's own doc).
+    buildGroupedSeries<InternalSeries, BarSegmentStyle>(resolvedSeries, segments, false),
   );
 
   function signedValue(s: InternalSeries, d: TData): number {
@@ -149,31 +172,47 @@
     }
     return map;
   });
+
+  // The single, fully-resolved scales object BasePlotLayout reads for
+  // everything (ticks, grid, sort, and the real svelteplot scale) — avoids
+  // keeping a second, separately-defaulted copy of `scales.x`/`scales.y`
+  // (our own diverging-domain + band-scale defaults) out of sync with the
+  // one actually forwarded.
+  const resolvedScales = $derived<AxisBasedScalesConfig<TData>>({
+    ...scales,
+    x: {
+      domain: [-maxMagnitude, maxMagnitude],
+      tickFormat: (v: unknown) => fmtVal(Math.abs(Number(v)), ''),
+      ...(scales.x ?? {}),
+    },
+    y: { type: 'band', padding: 0.2, domain: yDomain, ...(scales.y ?? {}) },
+  });
+
+  const hoverActive = $derived(tooltip != null || hasHoverMarker(markers));
+  const hoverStrategy = $derived(resolveHoverStrategy(tooltip?.strategy, markers, 'y'));
+  const hoverSync = $derived(resolveHoverSync(tooltip?.sync, markers));
 </script>
 
-<PlotLayout
+<BasePlotLayout
   {width}
   {height}
-  x={{
-    domain: [-maxMagnitude, maxMagnitude],
-    tickFormat: (v: unknown) => fmtVal(Math.abs(Number(v)), ''),
-    ...(scales.x ?? {}),
-  }}
-  y={{ type: 'band', padding: 0.2, domain: yDomain, ...(scales.y ?? {}) }}
   data={flat}
   {getX}
   {getY}
-  matchY={getY}
   {hoverPoints}
   label={labelFor}
   {tooltip}
-  {markers}
-  seriesData={resolvedSeries}
-  {scales}
+  {hoverActive}
+  {hoverStrategy}
+  {hoverSync}
+  scales={resolvedScales}
   {margins}
-  defaultStrategy="y"
+  xTickRotate={resolvedScales?.x?.tickRotate}
 >
-  {#snippet children({ matchedPoints, ruleX, ruleY, impliesRuleX, impliesRuleY })}
+  {#snippet children({ matchedPoints, ruleX, ruleY, impliesRuleX, impliesRuleY, numericMargins })}
+  <AxisLayout data={flat} {getX} {getY} {width} {height} {numericMargins} scales={resolvedScales} />
+  <GridLayout scales={resolvedScales} />
+  <RuleLayout {markers} seriesData={resolvedSeries} {matchedPoints} {ruleX} {ruleY} {impliesRuleX} {impliesRuleY}>
     {#each groupedSeries as group (group.series.name)}
       {@const defaultColor = group.series.side === 'left' ? leftColor : rightColor}
       {@const getCategory = resolveAccessor(group.series.x)}
@@ -210,14 +249,19 @@
           text={(d: TData) => fmtVal(Math.abs(Number(resolveAccessor(group.series.y)(d))), group.series.name)}
           dx={styles.values?.dx ?? defaultDx}
           dy={styles.values?.dy ?? 0}
-          textAnchor={styles.values?.textAnchor ?? defaultTextAnchor}
+          textAnchor={resolvedTextAnchor ?? defaultTextAnchor}
           lineAnchor={styles.values?.lineAnchor ?? 'middle'}
           lineHeight={styles.values?.lineHeight}
           rotate={styles.values?.rotate}
           class={styles.values?.class}
           textClass={styles.values?.textClass}
-          fill={cfg.axis.color}
-          fontSize={12}
+          fill={styles.values?.fill ?? cfg.axis.color}
+          fontSize={styles.values?.fontSize ?? 12}
+          fontWeight={styles.values?.fontWeight}
+          fontStyle={styles.values?.fontStyle}
+          stroke={styles.values?.stroke}
+          strokeWidth={styles.values?.strokeWidth}
+          paintOrder={styles.values?.paintOrder}
         />
       {/if}
 
@@ -282,5 +326,6 @@
         {/if}
       {/each}
     {/each}
+  </RuleLayout>
   {/snippet}
-</PlotLayout>
+</BasePlotLayout>

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

@@ -1,7 +1,11 @@
-import type { PlotProps } from '../../types/plots/props';
-import type { BarSegmentStyle } from '../../types/plots/styles';
+import type { BasePlotProps } from '../../types/plots/props';
+import type { SeriesProps, DataProps } from '../../types/plots/data/common';
+import type { AxisBasedScalesConfig } from '../../types/plots/props';
+import type { BasePlotStyles } from '../../types/plots/styles/common';
+import type { BarSegmentStyle } from '../../types/plots/segments/common';
+import type { Marker } from '../../types/markers/common';
 declare function $$render<TData extends Record<string, unknown>>(): {
-    props: PlotProps<TData, BarSegmentStyle>;
+    props: BasePlotProps<SeriesProps<TData> | DataProps<TData>, TData, BasePlotStyles, BarSegmentStyle, Marker, AxisBasedScalesConfig<TData>>;
     exports: {};
     bindings: "";
     slots: {};

package/dist/plots/utils/delta.d.ts

@@ -1,4 +1,4 @@
-import type { Series } from '../../types/plots/common';
+import type { Series } from '../../types/plots/data/common';
 import type { DeltaConfig } from '../../types/plots/delta';
 export type ResolvedDelta = {
     cfg: DeltaConfig;

package/dist/plots/utils/geoAccessors.d.ts

@@ -0,0 +1,64 @@
+import type { GeoFeature } from '../../types/plots/data/geo';
+/**
+ * Bounding-box center of a geometry's flattened coordinates — a cheap
+ * approximation used for default label placement, not a true
+ * geographic/area centroid (no polygon-hole or geodesic-area weighting).
+ * For hover-matching specifically, see `geometryPartCentroids` instead —
+ * this single combined point can land far from every actual part of a
+ * multi-part geometry whose pieces are geographically spread out.
+ */
+export declare function geometryCentroid(geometry: GeoJSON.Geometry): [number, number];
+/**
+ * Splits a geometry into its disjoint parts: one `Polygon` per element of a
+ * `MultiPolygon`'s `coordinates`, one `LineString` per element of a
+ * `MultiLineString`'s, `GeometryCollection` recursed and flattened, and any
+ * other geometry type returned unchanged as its own single-element array.
+ * The shared building block behind `geometryPartCentroids` (one centroid per
+ * part) and `filterGeometryParts` (keep/drop whole parts).
+ */
+export declare function splitGeometryParts(geometry: GeoJSON.Geometry): GeoJSON.Geometry[];
+/**
+ * Like `geometryCentroid`, but returns one point per disjoint part instead
+ * of a single bounding-box center across all of them. A `MultiPolygon`
+ * whose parts are geographically far apart — e.g. Argentina's "Tierra del
+ * Fuego, Antártida e Islas del Atlántico Sur" province, whose `MultiPolygon`
+ * spans the mainland island, the Antarctic sector, and the South Atlantic
+ * islands in one feature — would otherwise get a single hover point
+ * stranded somewhere between all of them, matching hovers over *none* of
+ * the actually-rendered shapes. Multiple points attributed to the same
+ * feature is fine for hover-matching (nearest point wins, whichever part
+ * that is); it's only label placement (`geometryCentroid`) that needs a
+ * single point.
+ */
+export declare function geometryPartCentroids(geometry: GeoJSON.Geometry): [number, number][];
+/**
+ * Keeps or drops each disjoint part of a geometry (see `splitGeometryParts`)
+ * based on a per-part predicate, reassembling a geometry of the same type
+ * from whatever survives — `null` if nothing does. Used to let a single
+ * feature's geometry be split between the main map and an `inset` marker
+ * (see `GeoDataProps.excludeParts`/`GeoInsetMarker.featurePartsFilter`)
+ * without preprocessing the source data: e.g. a province whose `MultiPolygon`
+ * spans both a mainland part and a far-flung part can have the main map
+ * exclude the latter while an inset shows only it.
+ */
+export declare function filterGeometryParts(geometry: GeoJSON.Geometry, keep: (part: {
+    centroid: [number, number];
+    geometry: GeoJSON.Geometry;
+}) => boolean): GeoJSON.Geometry | null;
+/** Default `featureId`: `feature.id`, else `properties.id`, else `properties.name`. */
+export declare function defaultFeatureId<TProps extends Record<string, unknown>>(f: GeoFeature<TProps>): string;
+/**
+ * Densifies a great-circle arc between two lon/lat points into `steps + 1`
+ * points via spherical linear interpolation (slerp) — used to draw a `link`
+ * marker's geodesic curve through the `Geo` mark (see `Plot.svelte`).
+ *
+ * Not delegated to svelteplot's own `Link` mark: its 0.14.2 projection
+ * integration (`Mark.svelte`'s paired-channel handling) reads a single
+ * `row.x`/`row.y` pair regardless of channel suffix, so a mark bound to
+ * `x1`/`y1`/`x2`/`y2` (never plain `x`/`y`) resolves every point as invalid
+ * whenever the plot has an active `projection` scale — which GeoPlot always
+ * does. `Geo` has no such limitation (geo marks are explicitly excluded from
+ * that code path), so a manually-interpolated `LineString` feature sidesteps
+ * the bug entirely while still producing the same geodesic visual.
+ */
+export declare function greatCircleInterpolate(lon1: number, lat1: number, lon2: number, lat2: number, steps?: number): [number, number][];

package/dist/plots/utils/geoAccessors.js

@@ -0,0 +1,188 @@
+function flattenCoords(geom, out) {
+    switch (geom.type) {
+        case 'Point':
+            out.push(geom.coordinates);
+            break;
+        case 'MultiPoint':
+        case 'LineString':
+            for (const c of geom.coordinates)
+                out.push(c);
+            break;
+        case 'MultiLineString':
+        case 'Polygon':
+            for (const ring of geom.coordinates) {
+                for (const c of ring)
+                    out.push(c);
+            }
+            break;
+        case 'MultiPolygon':
+            for (const poly of geom.coordinates) {
+                for (const ring of poly) {
+                    for (const c of ring)
+                        out.push(c);
+                }
+            }
+            break;
+        case 'GeometryCollection':
+            for (const g of geom.geometries)
+                flattenCoords(g, out);
+            break;
+    }
+}
+function boundsCenter(coords) {
+    if (coords.length === 0)
+        return [0, 0];
+    let minX = Infinity;
+    let maxX = -Infinity;
+    let minY = Infinity;
+    let maxY = -Infinity;
+    for (const [x, y] of coords) {
+        if (x < minX)
+            minX = x;
+        if (x > maxX)
+            maxX = x;
+        if (y < minY)
+            minY = y;
+        if (y > maxY)
+            maxY = y;
+    }
+    return [(minX + maxX) / 2, (minY + maxY) / 2];
+}
+/**
+ * Bounding-box center of a geometry's flattened coordinates — a cheap
+ * approximation used for default label placement, not a true
+ * geographic/area centroid (no polygon-hole or geodesic-area weighting).
+ * For hover-matching specifically, see `geometryPartCentroids` instead —
+ * this single combined point can land far from every actual part of a
+ * multi-part geometry whose pieces are geographically spread out.
+ */
+export function geometryCentroid(geometry) {
+    const coords = [];
+    flattenCoords(geometry, coords);
+    return boundsCenter(coords);
+}
+/**
+ * Splits a geometry into its disjoint parts: one `Polygon` per element of a
+ * `MultiPolygon`'s `coordinates`, one `LineString` per element of a
+ * `MultiLineString`'s, `GeometryCollection` recursed and flattened, and any
+ * other geometry type returned unchanged as its own single-element array.
+ * The shared building block behind `geometryPartCentroids` (one centroid per
+ * part) and `filterGeometryParts` (keep/drop whole parts).
+ */
+export function splitGeometryParts(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((g) => splitGeometryParts(g));
+        default:
+            return [geometry];
+    }
+}
+/**
+ * Like `geometryCentroid`, but returns one point per disjoint part instead
+ * of a single bounding-box center across all of them. A `MultiPolygon`
+ * whose parts are geographically far apart — e.g. Argentina's "Tierra del
+ * Fuego, Antártida e Islas del Atlántico Sur" province, whose `MultiPolygon`
+ * spans the mainland island, the Antarctic sector, and the South Atlantic
+ * islands in one feature — would otherwise get a single hover point
+ * stranded somewhere between all of them, matching hovers over *none* of
+ * the actually-rendered shapes. Multiple points attributed to the same
+ * feature is fine for hover-matching (nearest point wins, whichever part
+ * that is); it's only label placement (`geometryCentroid`) that needs a
+ * single point.
+ */
+export function geometryPartCentroids(geometry) {
+    return splitGeometryParts(geometry).map((part) => geometryCentroid(part));
+}
+/**
+ * Keeps or drops each disjoint part of a geometry (see `splitGeometryParts`)
+ * based on a per-part predicate, reassembling a geometry of the same type
+ * from whatever survives — `null` if nothing does. Used to let a single
+ * feature's geometry be split between the main map and an `inset` marker
+ * (see `GeoDataProps.excludeParts`/`GeoInsetMarker.featurePartsFilter`)
+ * without preprocessing the source data: e.g. a province whose `MultiPolygon`
+ * spans both a mainland part and a far-flung part can have the main map
+ * exclude the latter while an inset shows only it.
+ */
+export function filterGeometryParts(geometry, keep) {
+    const parts = splitGeometryParts(geometry);
+    const keptParts = parts.filter((part) => keep({ centroid: geometryCentroid(part), geometry: part }));
+    if (keptParts.length === parts.length)
+        return geometry;
+    if (keptParts.length === 0)
+        return null;
+    if (parts.length === 1)
+        return keptParts[0];
+    switch (geometry.type) {
+        case 'MultiPolygon':
+            return { type: 'MultiPolygon', coordinates: keptParts.map((part) => part.coordinates) };
+        case 'MultiLineString':
+            return {
+                type: 'MultiLineString',
+                coordinates: keptParts.map((part) => part.coordinates),
+            };
+        case 'GeometryCollection':
+            return { type: 'GeometryCollection', geometries: keptParts };
+        default:
+            return geometry;
+    }
+}
+/** Default `featureId`: `feature.id`, else `properties.id`, else `properties.name`. */
+export function defaultFeatureId(f) {
+    const props = f.properties;
+    return String(f.id ?? props?.id ?? props?.name ?? '');
+}
+function toRad(deg) {
+    return (deg * Math.PI) / 180;
+}
+function toDeg(rad) {
+    return (rad * 180) / Math.PI;
+}
+/**
+ * Densifies a great-circle arc between two lon/lat points into `steps + 1`
+ * points via spherical linear interpolation (slerp) — used to draw a `link`
+ * marker's geodesic curve through the `Geo` mark (see `Plot.svelte`).
+ *
+ * Not delegated to svelteplot's own `Link` mark: its 0.14.2 projection
+ * integration (`Mark.svelte`'s paired-channel handling) reads a single
+ * `row.x`/`row.y` pair regardless of channel suffix, so a mark bound to
+ * `x1`/`y1`/`x2`/`y2` (never plain `x`/`y`) resolves every point as invalid
+ * whenever the plot has an active `projection` scale — which GeoPlot always
+ * does. `Geo` has no such limitation (geo marks are explicitly excluded from
+ * that code path), so a manually-interpolated `LineString` feature sidesteps
+ * the bug entirely while still producing the same geodesic visual.
+ */
+export function greatCircleInterpolate(lon1, lat1, lon2, lat2, steps = 64) {
+    const phi1 = toRad(lat1);
+    const lambda1 = toRad(lon1);
+    const phi2 = toRad(lat2);
+    const lambda2 = toRad(lon2);
+    const sinPhi1 = Math.sin(phi1);
+    const cosPhi1 = Math.cos(phi1);
+    const sinPhi2 = Math.sin(phi2);
+    const cosPhi2 = Math.cos(phi2);
+    const d = 2 *
+        Math.asin(Math.sqrt(Math.sin((phi2 - phi1) / 2) ** 2 + cosPhi1 * cosPhi2 * Math.sin((lambda2 - lambda1) / 2) ** 2));
+    if (!Number.isFinite(d) || d === 0) {
+        return [
+            [lon1, lat1],
+            [lon2, lat2],
+        ];
+    }
+    const points = [];
+    for (let i = 0; i <= steps; i++) {
+        const f = i / steps;
+        const a = Math.sin((1 - f) * d) / Math.sin(d);
+        const b = Math.sin(f * d) / Math.sin(d);
+        const x = a * cosPhi1 * Math.cos(lambda1) + b * cosPhi2 * Math.cos(lambda2);
+        const y = a * cosPhi1 * Math.sin(lambda1) + b * cosPhi2 * Math.sin(lambda2);
+        const z = a * sinPhi1 + b * sinPhi2;
+        const phi = Math.atan2(z, Math.sqrt(x * x + y * y));
+        const lambda = Math.atan2(y, x);
+        points.push([toDeg(lambda), toDeg(phi)]);
+    }
+    return points;
+}

package/dist/plots/utils/geoSegments.d.ts

@@ -0,0 +1,14 @@
+import type { Segment } from '../../types/plots/segments/config';
+import type { SegmentsConfig } from '../../types/plots/props';
+/** Feature-specific segments listed after 'default' so they override it on merge (see `resolveFeatureStyle`). */
+export declare function resolveSegmentsForFeature<TStyle>(segments: SegmentsConfig<TStyle>, featureId: string): Segment<TStyle>[];
+/**
+ * A geo feature is atomic — `Segment.areas` (x/y range restriction) doesn't
+ * apply, so every entry under a key is treated as a flat style patch applied
+ * in order: `'default'` entries apply first, feature-specific entries
+ * override. This intentionally does NOT reuse `segments.ts`'s
+ * `validateSegments` — its "only the first catch-all wins" warning assumes
+ * area-based semantics that don't hold here, since every geo segment entry
+ * merges rather than being dropped.
+ */
+export declare function resolveFeatureStyle<TStyle extends object>(segments: SegmentsConfig<TStyle>, featureId: string): TStyle;

package/dist/plots/utils/geoSegments.js

@@ -0,0 +1,17 @@
+const DEFAULT_KEY = 'default';
+/** Feature-specific segments listed after 'default' so they override it on merge (see `resolveFeatureStyle`). */
+export function resolveSegmentsForFeature(segments, featureId) {
+    return [...(segments[DEFAULT_KEY] ?? []), ...(segments[featureId] ?? [])];
+}
+/**
+ * A geo feature is atomic — `Segment.areas` (x/y range restriction) doesn't
+ * apply, so every entry under a key is treated as a flat style patch applied
+ * in order: `'default'` entries apply first, feature-specific entries
+ * override. This intentionally does NOT reuse `segments.ts`'s
+ * `validateSegments` — its "only the first catch-all wins" warning assumes
+ * area-based semantics that don't hold here, since every geo segment entry
+ * merges rather than being dropped.
+ */
+export function resolveFeatureStyle(segments, featureId) {
+    return resolveSegmentsForFeature(segments, featureId).reduce((acc, seg) => ({ ...acc, ...(seg.style ?? {}) }), {});
+}

package/dist/plots/utils/segments.d.ts

@@ -1,11 +1,14 @@
-import type { AxisValue, Series } from '../../types/plots/common';
-import type { Segment, Segments, LineSegmentStyle, VisualGroup } from '../../types/plots/styles';
+import type { AxisValue } from '../../types/plots/axis';
+import type { Series } from '../../types/plots/data/common';
+import type { LineSegmentStyle } from '../../types/plots/segments/common';
+import type { Segment, VisualGroup } from '../../types/plots/segments/config';
+import type { SegmentsConfig } from '../../types/plots/props';
 /**
  * Returns the flat {@link Segment} list for one series.
  * Series-specific segments are added before `'default'` segments so that
  * series-specific catch-alls win over default catch-alls on tie-breaks.
  */
-export declare function resolveSegmentsForSeries<TStyle>(segments: Segments<TStyle>, seriesName: string): Segment<TStyle>[];
+export declare function resolveSegmentsForSeries<TStyle>(segments: SegmentsConfig<TStyle>, seriesName: string): Segment<TStyle>[];
 /** Returns true when `xVal` falls inside any of a segment's x ranges. */
 export declare function matchesSegmentX<TStyle>(xVal: AxisValue, seg: Segment<TStyle>): boolean;
 /**
@@ -22,10 +25,16 @@ export declare function getDataForSegments<TData, TStyle>(data: TData[], xAccess
  * (no `areas`) in the same series list. Since catch-alls are evaluated last
  * and in order, only the first one can ever match; later ones are dead code.
  */
-export declare function validateSegments<TStyle>(segments: Segments<TStyle>): void;
+export declare function validateSegments<TStyle>(segments: SegmentsConfig<TStyle>): void;
 /**
  * Builds the full list of visual groups — one per series — ready to render.
  * Each group's `visualSegments` is derived by resolving the flat segment list
  * for that series from all groups in `segments`.
+ *
+ * `connect` bridges adjacent visual segments so a *continuous* mark (line)
+ * has no visual gap at their boundary — the default, since `buildGroupedSeries`
+ * itself defaults `TStyle` to {@link LineSegmentStyle}. Discrete marks (bar,
+ * pyramid) have no gap to bridge; pass `connect: false` so boundary rows
+ * aren't duplicated as an extra, separately-styled mark.
  */
-export declare function buildGroupedSeries<S extends Series<any>, TStyle = LineSegmentStyle>(seriesList: S[], segments: Segments<TStyle>): VisualGroup<S, TStyle>[];
+export declare function buildGroupedSeries<S extends Series<any>, TStyle = LineSegmentStyle>(seriesList: S[], segments: SegmentsConfig<TStyle>, connect?: boolean): VisualGroup<S, TStyle>[];

package/dist/plots/utils/segments.js

@@ -90,7 +90,7 @@ function mergeStyles(base, override) {
     return result;
 }
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-function resolveSeriesSegments(series, segs) {
+function resolveSeriesSegments(series, segs, connect) {
     if (!segs.length) {
         return [{ data: series.data, style: {} }];
     }
@@ -147,14 +147,18 @@ function resolveSeriesSegments(series, segs) {
     for (let r = 0; r < runs.length; r++) {
         const run = runs[r];
         if (run.segIdx === -1) {
-            // Unmatched run: insert bridge points so the line connects to adjacent
-            // user segments without a gap.
-            const bridged = [];
-            if (r > 0)
-                bridged.push(runs[r - 1].data[runs[r - 1].data.length - 1]);
-            bridged.push(...run.data);
-            if (r < runs.length - 1)
-                bridged.push(runs[r + 1].data[0]);
+            // Unmatched run: for a continuous mark (line), insert bridge points so
+            // it connects to adjacent user segments without a visual gap. Discrete
+            // marks (bar, pyramid) have no such gap to bridge — bridging would just
+            // duplicate the neighboring runs' boundary rows as an extra, wrongly
+            // styled mark at that same category.
+            const bridged = [...run.data];
+            if (connect) {
+                if (r > 0)
+                    bridged.unshift(runs[r - 1].data[runs[r - 1].data.length - 1]);
+                if (r < runs.length - 1)
+                    bridged.push(runs[r + 1].data[0]);
+            }
             defaultVisual.push({ data: bridged, style: {} });
         }
         else {
@@ -170,9 +174,11 @@ function resolveSeriesSegments(series, segs) {
             // When the next run is also a user segment (no unmatched data between them),
             // insert a line-only connector so the lines join without a gap. Using a
             // separate mark (rather than appending a bridge point to the current run)
-            // avoids rendering an extra dot at the shared boundary point.
+            // avoids rendering an extra dot at the shared boundary point. Skipped
+            // entirely for discrete marks (see above) — it would duplicate both
+            // runs' boundary rows as an extra mark.
             const nextRun = runs[r + 1];
-            if (nextRun && nextRun.segIdx !== -1) {
+            if (connect && nextRun && nextRun.segIdx !== -1) {
                 connectors.push({
                     data: [run.data[run.data.length - 1], nextRun.data[0]],
                     style: connectorStyle,
@@ -190,10 +196,16 @@ function resolveSeriesSegments(series, segs) {
  * Builds the full list of visual groups — one per series — ready to render.
  * Each group's `visualSegments` is derived by resolving the flat segment list
  * for that series from all groups in `segments`.
+ *
+ * `connect` bridges adjacent visual segments so a *continuous* mark (line)
+ * has no visual gap at their boundary — the default, since `buildGroupedSeries`
+ * itself defaults `TStyle` to {@link LineSegmentStyle}. Discrete marks (bar,
+ * pyramid) have no gap to bridge; pass `connect: false` so boundary rows
+ * aren't duplicated as an extra, separately-styled mark.
  */
-export function buildGroupedSeries(seriesList, segments) {
+export function buildGroupedSeries(seriesList, segments, connect = true) {
     return seriesList.map((s) => ({
         series: s,
-        visualSegments: resolveSeriesSegments(s, resolveSegmentsForSeries(segments, s.name)),
+        visualSegments: resolveSeriesSegments(s, resolveSegmentsForSeries(segments, s.name), connect),
     }));
 }