@fundar/data-chart-telling 0.0.64 → 1.1.0

package/dist/markers/ContourClipMarker.svelte

@@ -1,77 +0,0 @@
-<script lang="ts">
-  import { geoPath, type GeoPath } from 'd3-geo';
-  import { usePlot } from 'svelteplot';
-  import type { Snippet } from 'svelte';
-  import type { GeoFeature } from '../types/plots/data/geo';
-
-  /**
-   * Masks a `contour` marker to just the landmass (`'land'`) or just the
-   * water (`'ocean'`) of the plot's own base map, via an SVG `clipPath` —
-   * lets a filled contour read as "temperature over land" without also
-   * painting straight across the ocean, or vice versa. A no-op passthrough
-   * when `mode` is unset, so this can unconditionally wrap every `contour`
-   * marker without an extra branch at each call site.
-   *
-   * Builds the clip path from the plot's own shared, already-fitted
-   * projection (`usePlot()` — the same hook `TileLayer.svelte` uses) rather
-   * than an independent one, so it lines up with the rest of the map
-   * regardless of projection/zoom. `'ocean'` unions the sphere and land
-   * paths into one `clip-rule: evenodd` shape — the sphere covers
-   * everything, then every land ring toggles back out, leaving only water.
-   */
-  let {
-    mode,
-    features,
-    children,
-  }: {
-    mode: 'land' | 'ocean' | undefined;
-    features: GeoFeature<Record<string, unknown>>[];
-    children: Snippet;
-  } = $props();
-
-  const plot = usePlot();
-  const clipId = `geo-contour-clip-${Math.random().toString(36).slice(2, 9)}`;
-
-  // Same runtime shape TileLayer.svelte relies on — svelteplot's own
-  // `PlotScale` type doesn't reflect it, but `plot.scales.projection` is a
-  // real `d3-geo`-compatible stream source at runtime.
-  const path: GeoPath = $derived(geoPath(plot.scales.projection as unknown as Parameters<typeof geoPath>[0]));
-  // Some real-world datasets carry exact-duplicate features for the same
-  // territory (seen in this repo's own `WORLD_COUNTRIES` fixture, for every
-  // South American country) — harmless for an ordinary filled `<Geo>` (the
-  // duplicate just redraws the same shape), but fatal here: two identical,
-  // oppositely-would-be-redundant copies of the same ring toggle each other
-  // back out under `clip-rule: evenodd`, silently punching a hole exactly
-  // where the duplicated territory is. Deduping by geometry keeps this
-  // correct regardless of whether the caller's data happens to be clean.
-  const uniqueGeometries = $derived(
-    Array.from(new Map(features.map((f) => [JSON.stringify(f.geometry), f as unknown as GeoJSON.Feature])).values()),
-  );
-  const landPath = $derived(
-    uniqueGeometries
-      .map((f) => path(f))
-      .filter((d): d is string => !!d)
-      .join(' '),
-  );
-  // `{type: 'Sphere'}` is d3-geo's own pseudo-geometry for "the whole
-  // globe" — not part of the GeoJSON spec, so `@types/geojson` has no type
-  // for it either.
-  const spherePath = $derived(path({ type: 'Sphere' } as unknown as GeoJSON.Feature) ?? '');
-</script>
-
-{#if mode}
-  <defs>
-    <clipPath id={clipId}>
-      {#if mode === 'land'}
-        <path d={landPath} clip-rule="evenodd" />
-      {:else}
-        <path d="{spherePath} {landPath}" clip-rule="evenodd" />
-      {/if}
-    </clipPath>
-  </defs>
-  <g clip-path="url(#{clipId})">
-    {@render children()}
-  </g>
-{:else}
-  {@render children()}
-{/if}

package/dist/markers/ContourMarker.svelte

@@ -1,28 +0,0 @@
-<script lang="ts">
-  import { Contour } from 'svelteplot';
-  import type { GeoContourMarkerConfig } from '../types/markers/geo';
-
-  /**
-   * Renders one `'contour'` marker's `<Contour>` mark. `marker.clip` is
-   * handled by the caller (`GeometryLayout` wraps this in `ContourClipMarker`)
-   * — this component only draws the contour itself.
-   */
-  let { marker }: { marker: GeoContourMarkerConfig } = $props();
-</script>
-
-<!-- No `?? 'none'` fallback: an unset `fill` should leave svelteplot's own default (`fill="none"`) in place, not run the literal string `'none'` through the color scale. -->
-<Contour
-  class="contour"
-  data={marker.data}
-  x={marker.x}
-  y={marker.y}
-  value={marker.value}
-  thresholds={marker.thresholds}
-  fill={marker.fill}
-  stroke={marker.stroke ?? 'currentColor'}
-  strokeWidth={marker.style?.strokeWidth}
-  fillOpacity={marker.style?.fillOpacity}
-  strokeOpacity={marker.style?.strokeOpacity}
-  blur={marker.blur}
-  interpolate={marker.interpolate}
-/>

package/dist/markers/DeltaMarker.svelte

@@ -1,109 +0,0 @@
-<script
-  lang="ts"
-  generics="TData extends Record<string, unknown>"
->
-  import { Line } from 'svelteplot';
-  import DotMarker from './DotMarker.svelte';
-  import TextMarker from './TextMarker.svelte';
-  import { resolveXDeltas, resolveYDeltas } from '../utils/delta';
-  import type { Series } from '../types/plots/data/common';
-  import type { DeltaMarkerConfig } from '../types/markers/line';
-
-  let { marker, data = [] }: { marker: DeltaMarkerConfig; data?: Series<TData>[] } = $props();
-
-  const resolved = $derived.by(() => {
-    const [d] = marker.axis === 'x' ? resolveXDeltas(data, [marker]) : resolveYDeltas(data, [marker]);
-    return d;
-  });
-
-  const clampRange = $derived.by((): [number, number] | undefined => {
-    const domain = marker.axis === 'x' ? marker.yDomain : marker.xDomain;
-    if (!domain || domain.length < 2) return undefined;
-    const lo = Number(domain[0]);
-    const hi = Number(domain[domain.length - 1]);
-    return isNaN(lo) || isNaN(hi) ? undefined : [Math.min(lo, hi), Math.max(lo, hi)];
-  });
-
-  function clamp(v: number): number {
-    return clampRange ? Math.max(clampRange[0], Math.min(clampRange[1], v)) : v;
-  }
-
-  function pt(fixed: number, varying: number) {
-    return marker.axis === 'x' ? { x: fixed, y: varying } : { x: varying, y: fixed };
-  }
-
-  function textVaryCoord(fromVis: number, toVis: number) {
-    const anchor = marker.fontStyle?.lineAnchor ?? 'middle';
-    return anchor === 'top'
-      ? Math.max(fromVis, toVis)
-      : anchor === 'bottom'
-      ? Math.min(fromVis, toVis)
-      : (fromVis + toVis) / 2;
-  }
-
-  // Pre-derive all coordinates as script-level signals so prop getters read safe
-  // values during Svelte 5 teardown, before the {#if} guard finishes unmounting.
-  const coords = $derived.by(() => {
-    if (!resolved) return null;
-    const fromVis = clamp(resolved.from ?? 0);
-    const toVis = clamp(resolved.to ?? 0);
-    const at = resolved.at ?? 0;
-    return {
-      fromPt: pt(at, fromVis),
-      toPt: pt(at, toVis),
-      textPt: pt(at, textVaryCoord(fromVis, toVis)),
-      lineData: [pt(at, fromVis), pt(at, toVis)],
-      diff: resolved.diff ?? 0,
-    };
-  });
-</script>
-
-{#if coords}
-  <Line
-    data={coords.lineData}
-    x={(p) => p.x}
-    y={(p) => p.y}
-    stroke={marker.strokeStyle?.stroke ?? 'currentColor'}
-    strokeWidth={marker.strokeStyle?.strokeWidth ?? 2}
-    strokeOpacity={marker.strokeStyle?.strokeOpacity ?? 0.8}
-    strokeDasharray={marker.strokeStyle?.strokeDasharray ?? '6 6'}
-    strokeLinecap={marker.strokeStyle?.strokeLinecap ?? 'round'}
-  />
-  <DotMarker
-    x={coords?.fromPt?.x ?? 0}
-    y={coords?.fromPt?.y ?? 0}
-    style={{
-      dotRadius: 4,
-      dotFill: marker.strokeStyle?.stroke,
-      dotStroke: marker.strokeStyle?.stroke,
-      dotStrokeWidth: 2,
-      ...marker.dotStyle,
-    }}
-  />
-  <DotMarker
-    x={coords?.toPt?.x ?? 0}
-    y={coords?.toPt?.y ?? 0}
-    style={{
-      dotRadius: 4,
-      dotFill: marker.strokeStyle?.stroke,
-      dotStroke: marker.strokeStyle?.stroke,
-      dotStrokeWidth: 2,
-      ...marker.dotStyle,
-    }}
-  />
-  <TextMarker
-    x={coords?.textPt?.x ?? 0}
-    y={coords?.textPt?.y ?? 0}
-    text={(marker.formatDiff ?? ((v: number) => v.toFixed(1)))(coords?.diff ?? 0)}
-    style={{
-      fontWeight: 'bold',
-      fontSize: 14,
-      textAnchor: 'middle',
-      fill: marker.strokeStyle?.stroke ?? 'currentColor',
-      ...marker.fontStyle,
-      dx: marker.fontStyle?.dx ?? (marker.axis === 'x' ? 12 : 0),
-      dy: marker.fontStyle?.dy ?? (marker.axis === 'x' ? 0 : -10),
-      lineAnchor: marker.axis === 'x' ? (marker.fontStyle?.lineAnchor ?? 'middle') : 'bottom',
-    }}
-  />
-{/if}

package/dist/markers/DotMarker.svelte

@@ -1,70 +0,0 @@
-<script lang="ts" generics="TData = Record<string, unknown>">
-  import { Dot } from 'svelteplot';
-  import { makeColorScale } from '../utils/color';
-  import { getConfiguration } from '../configuration/config.svelte';
-  import type { MarkerProps } from '../types/markers/props';
-  import type { AxisValue } from '../types/layout/scales';
-  import type { DotStyle } from '../types/plots/styling';
-  import type { ColorsStyle } from '../types/layout/styles';
-
-  interface Props extends MarkerProps<TData> {
-    x?: AxisValue | ((d: TData) => AxisValue);
-    y?: AxisValue | ((d: TData) => AxisValue);
-    /** Per-row radius, or a constant — overrides `style.dotRadius` when set. */
-    r?: number | ((d: TData) => number);
-    /** Per-row fill, overriding `style.dotFill` — ignored when `value` is set. */
-    fill?: (d: TData) => string;
-    /** Continuous value driving a per-dot color ramp through `style.colors` — takes priority over `fill`/`style.dotFill` when set. */
-    value?: (d: TData) => number;
-    style?: DotStyle & { colors?: ColorsStyle };
-  }
-
-  const { data = [], x, y, r: rProp, fill: fillProp, value, style }: Props = $props();
-
-  const cfg = $derived(getConfiguration());
-
-  const xAccessor = $derived(typeof x === 'function' ? x : () => x ?? 0);
-  const yAccessor = $derived(typeof y === 'function' ? y : () => y ?? 0);
-  /** A literal `x`/`y` draws one dot at a fixed point regardless of `data`; an accessor reads its position per row. */
-  const displayData = $derived(
-    data.length > 0 || typeof x === 'function' || typeof y === 'function' ? data : [{} as TData],
-  );
-
-  /** Color scale built from `value`'s own data extent — `null` when `value` is unset. */
-  const valueColorScale = $derived.by(() => {
-    if (!value) return null;
-    const vals = displayData.map((d) => Number(value(d))).filter((v) => Number.isFinite(v));
-    if (!vals.length) return null;
-    return makeColorScale(
-      Math.min(...vals),
-      Math.max(...vals),
-      style?.colors?.min ?? cfg.continuous.min,
-      style?.colors?.max ?? cfg.continuous.max,
-    );
-  });
-
-  const r = $derived(rProp ?? style?.dotRadius ?? 5);
-  const fill = $derived(
-    valueColorScale && value ? (d: TData) => valueColorScale(Number(value(d))) : (fillProp ?? style?.dotFill ?? 'currentColor'),
-  );
-  const fillOpacity = $derived(style?.dotFillOpacity ?? 1);
-  const symbol = $derived(style?.dotSymbol ?? 'circle');
-  const stroke = $derived(style?.dotStroke ?? 'currentColor');
-  const strokeWidth = $derived(style?.dotStrokeWidth ?? 1);
-  const strokeOpacity = $derived(style?.dotStrokeOpacity ?? 1);
-  const strokeDasharray = $derived(style?.dotStrokeDasharray);
-</script>
-
-<Dot
-  data={displayData}
-  x={xAccessor}
-  y={yAccessor}
-  {r}
-  {fill}
-  {fillOpacity}
-  {stroke}
-  {strokeWidth}
-  {strokeOpacity}
-  {strokeDasharray}
-  {symbol}
-/>

package/dist/markers/GeoFeaturesMarker.svelte

@@ -1,19 +0,0 @@
-<script lang="ts">
-  import { Geo } from 'svelteplot';
-  import type { GeoFeaturesMarkerConfig } from '../types/markers/geo';
-
-  /** Renders one `'geo'` marker — one resolved-style bucket of the base map's own features, as a single `<Geo>` call. */
-  let { marker }: { marker: GeoFeaturesMarkerConfig } = $props();
-</script>
-
-<Geo
-  data={marker.data}
-  fill={marker.fill}
-  fillOpacity={marker.fillOpacity ?? 1}
-  stroke={marker.stroke ?? 'currentColor'}
-  strokeWidth={marker.strokeWidth ?? 0.5}
-  style="vector-effect: non-scaling-stroke"
-  onclick={marker.onclick}
-  onpointerenter={marker.onpointerenter}
-  onpointerleave={marker.onpointerleave}
-/>

package/dist/markers/GeoHoverMarker.svelte

@@ -1,25 +0,0 @@
-<script lang="ts">
-  import { Geo } from 'svelteplot';
-  import { getConfiguration } from '../configuration/config.svelte';
-  import type { GeoHoverMarkerConfig } from '../types/markers/geo';
-  import type { HoverPoint } from '../types/layout/tooltip';
-
-  /** Renders the hovered feature restyled in place — no dot, no label. `pointer-events: none` so it never steals hover from the base map underneath it. */
-  let { marker, data }: { marker: GeoHoverMarkerConfig; data: HoverPoint<Record<string, unknown>>[] } = $props();
-
-  const cfg = $derived(getConfiguration());
-  const style = $derived({ ...cfg.hover.area, ...marker.style });
-</script>
-
-{#if data.length > 0}
-  <Geo
-    data={data.map((p) => p.row)}
-    fill={style.fill}
-    fillOpacity={style.fillOpacity}
-    stroke={style.stroke}
-    strokeWidth={style.strokeWidth}
-    strokeOpacity={style.strokeOpacity}
-    strokeDasharray={style.strokeDasharray}
-    style="vector-effect: non-scaling-stroke; pointer-events: none;"
-  />
-{/if}

package/dist/markers/GraticuleMarker.svelte

@@ -1,18 +0,0 @@
-<script lang="ts">
-  import { Graticule } from 'svelteplot';
-  import type { GeoGraticuleMarkerConfig } from '../types/markers/geo';
-
-  /** Renders one `'graticule'` marker — longitude/latitude gridlines. */
-  let { marker }: { marker: GeoGraticuleMarkerConfig } = $props();
-</script>
-
-<Graticule
-  step={marker.step}
-  stepX={marker.stepX}
-  stepY={marker.stepY}
-  stroke={marker.style?.stroke ?? 'currentColor'}
-  strokeWidth={marker.style?.strokeWidth ?? 0.5}
-  strokeOpacity={marker.style?.strokeOpacity ?? 0.3}
-  strokeDasharray={marker.style?.strokeDasharray}
-  style="vector-effect: non-scaling-stroke"
-/>

package/dist/markers/HoverMarker.svelte

@@ -1,212 +0,0 @@
-<script lang="ts">
-  import { usePlot } from 'svelteplot';
-  import DotMarker from './DotMarker.svelte';
-  import TextMarker from './TextMarker.svelte';
-  import RuleMarker from './RuleMarker.svelte';
-  import BarMarker from './BarMarker.svelte';
-  import { getConfiguration } from '../configuration/config.svelte';
-  import type { MarkerProps } from '../types/markers/props';
-  import type { HoverMarkerConfig } from '../types/markers/common';
-  import type { HoverDisplayPoint } from '../types/layout/tooltip';
-
-  /**
-   * In-SVG hover highlight, rendered *inside* a `<Plot>`. Because it positions
-   * itself through the host plot's scales, it places the same coordinate
-   * correctly in every facet — that is what makes cross-facet sync work without
-   * any pixel math. Draws optional x/y crosshair rules plus a dot + value label
-   * for each matched point.
-   *
-   * Takes the raw `marker` config plus the couple of things it can't know on
-   * its own — `activePoint` (the specific matched point actually under the
-   * cursor, for the crosshair position; see `controller.svelte.ts`'s own doc
-   * comment) and whether the active hover strategy implies a crosshair on
-   * each axis by default — the same "component owns its own rendering"
-   * pattern `BarMarker`/`RuleMarker` follow. `activePoint`/
-   * `impliesCrosshairX`/`impliesCrosshairY` are all optional and default to
-   * "no crosshair".
-   *
-   * `areaX`/`areaY` are a separate, always-explicit opt-in (no implied
-   * default) for a thickened area highlight in place of the thin crosshair —
-   * see `HoverMarkerConfig`'s own doc comment. Rendered via `BarMarker`'s
-   * `role: 'highlight'`, so it renders nothing on an axis without a band
-   * scale (e.g. a line/scatter plot's continuous axis).
-   */
-  interface Props extends MarkerProps<HoverDisplayPoint> {
-    /** Narrowed to just the fields this component reads — `HoverMarkerConfig` also carries routing/scoping fields (`series`/`scope`/`strategy`/`sync`) it has no use for. */
-    marker: Pick<
-      HoverMarkerConfig,
-      'ruleX' | 'ruleY' | 'areaX' | 'areaY' | 'showLabels' | 'format' | 'ruleStyle' | 'areaStyle' | 'dotStyle' | 'fontStyle'
-    >;
-    activePoint?: HoverDisplayPoint | null;
-    impliesCrosshairX?: boolean;
-    impliesCrosshairY?: boolean;
-    /** Reports `activePoint`'s real pixel position within this facet's own box, or `null` when nothing's matched. */
-    onActivePointPixel?: (pos: { x: number; y: number } | null) => void;
-  }
-
-  let {
-    data = [],
-    marker,
-    activePoint = null,
-    impliesCrosshairX = false,
-    impliesCrosshairY = false,
-    seriesColor,
-    onActivePointPixel,
-  }: Props = $props();
-
-  const cfg = $derived(getConfiguration());
-  const plot = usePlot();
-
-  /** Scaled pixel position of `value`, centered within its band for a band scale. */
-  function scaledPixel(scale: { type?: string; fn?: (v: never) => unknown } | undefined, value: unknown): number | null {
-    if (!scale?.fn || value == null) return null;
-    const raw = Number(scale.fn(value as never));
-    if (!Number.isFinite(raw)) return null;
-    if (scale.type === 'band') {
-      const bandwidth = (scale.fn as { bandwidth?: () => number }).bandwidth?.() ?? 0;
-      return raw + bandwidth / 2;
-    }
-    return raw;
-  }
-
-  const activePixel = $derived.by((): { x: number; y: number } | null => {
-    if (!activePoint) return null;
-    const x = scaledPixel(plot.scales.x, activePoint.x);
-    const y = scaledPixel(plot.scales.y, activePoint.y);
-    if (x == null || y == null) return null;
-    return { x: x + (activePoint.dx ?? 0), y: y + (activePoint.dy ?? 0) };
-  });
-
-  $effect(() => {
-    onActivePointPixel?.(activePixel);
-  });
-
-  const showCrosshairX = $derived(marker.ruleX !== false && (impliesCrosshairX || marker.ruleX === true));
-  const showCrosshairY = $derived(marker.ruleY !== false && (impliesCrosshairY || marker.ruleY === true));
-  const ruleX = $derived(showCrosshairX ? (activePoint?.x ?? null) : null);
-  const ruleY = $derived(showCrosshairY ? (activePoint?.y ?? null) : null);
-  // areaX/areaY have no implied default — always off unless explicitly set.
-  const areaX = $derived(marker.areaX === true ? (activePoint?.x ?? null) : null);
-  const areaY = $derived(marker.areaY === true ? (activePoint?.y ?? null) : null);
-  const showLabels = $derived(marker.showLabels ?? true);
-  const format = $derived(marker.format);
-  const ruleStyle = $derived(marker.ruleStyle);
-  const areaStyle = $derived({ ...cfg.hover.area, ...marker.areaStyle });
-  const dotStyle = $derived(marker.dotStyle);
-  const fontStyle = $derived(marker.fontStyle);
-
-  /** Explicit style wins; otherwise fall back to the series color, then the point's own resolved color. */
-  const resolveColor = (explicit: string | undefined, point: HoverDisplayPoint) =>
-    explicit ?? seriesColor ?? point.color;
-
-  // Horizontal gap between the dot's edge and an 'outside'-anchored label —
-  // scales with the dot's own resolved radius so the label clears it.
-  const dotRadius = $derived(dotStyle?.dotRadius ?? cfg.hover.dot.dotRadius ?? 5);
-
-  /**
-   * Resolves `fontStyle.textAnchor: 'outside'` into a per-point anchor +
-   * offset, mirroring the value-label `'outside'` anchor's own left/right
-   * split (see pyramid/bar's own `ValueAnchor` handling): a positive `x`
-   * anchors `'start'` and nudges right, a negative `x` anchors `'end'` and
-   * nudges left — so a diverging mark's label sits on the side of the dot
-   * away from zero, on whichever side that dot itself landed. Only
-   * meaningful when the point's `x` is numeric (e.g. pyramid's magnitude
-   * axis); anything else falls through to the plain `fontStyle` unchanged.
-   *
-   * Also overrides `cfg.hover.font`'s default `dy: -18` (meant for a label
-   * floating *above* the dot) back to vertically centered, and clears the
-   * dot's own radius horizontally instead of the flat default nudge, so the
-   * label doesn't collide with the dot it's labeling.
-   */
-  function resolveFontStyle(point: HoverDisplayPoint) {
-    if (fontStyle?.textAnchor !== 'outside' || typeof point.x !== 'number') {
-      return { ...cfg.hover.font, ...fontStyle, fill: resolveColor(fontStyle?.fill, point) };
-    }
-    const outward = point.x >= 0;
-    const gap = dotRadius + 5;
-    return {
-      ...cfg.hover.font,
-      ...fontStyle,
-      fill: resolveColor(fontStyle?.fill, point),
-      textAnchor: outward ? ('start' as const) : ('end' as const),
-      lineAnchor: fontStyle?.lineAnchor ?? ('middle' as const),
-      dx: fontStyle?.dx ?? (outward ? gap : -gap),
-      dy: fontStyle?.dy ?? 0,
-    };
-  }
-</script>
-
-{#if areaX != null}
-  <BarMarker
-    marker={{
-      type: 'bar',
-      role: 'highlight',
-      isHorizontal: false,
-      data: [],
-      category: areaX,
-      insetLeft: activePoint?.areaInset?.start,
-      insetRight: activePoint?.areaInset?.end,
-      style: areaStyle,
-    }}
-  />
-{/if}
-
-{#if areaY != null}
-  <BarMarker
-    marker={{
-      type: 'bar',
-      role: 'highlight',
-      isHorizontal: true,
-      data: [],
-      category: areaY,
-      insetTop: activePoint?.areaInset?.start,
-      insetBottom: activePoint?.areaInset?.end,
-      style: areaStyle,
-    }}
-  />
-{/if}
-
-{#if ruleX != null}
-  <g transform="translate({activePoint?.dx ?? 0}, {activePoint?.dy ?? 0})">
-    <RuleMarker axis="x" value={ruleX} style={{ ...cfg.hover.rule, ...ruleStyle }} />
-  </g>
-{/if}
-
-{#if ruleY != null}
-  <g transform="translate({activePoint?.dx ?? 0}, {activePoint?.dy ?? 0})">
-    <RuleMarker axis="y" value={ruleY} style={{ ...cfg.hover.rule, ...ruleStyle }} />
-  </g>
-{/if}
-
-{#if data.length > 0}
-  {#each data as point (`${point.series ?? ''}_${point.x}_${point.y}`)}
-    <!-- Pixel nudge for plot kinds whose series position isn't fully captured
-         by x/y alone (e.g. BarPlot's 'grouped' layout) — see HoverDisplayPoint.dx/dy. -->
-    <g transform="translate({point.dx ?? 0}, {point.dy ?? 0})">
-      <DotMarker
-        data={[point]}
-        x={(d) => d.x}
-        y={(d) => d.y}
-        style={{
-          ...cfg.hover.dot,
-          ...dotStyle,
-          dotFill: resolveColor(dotStyle?.dotFill, point),
-          dotStroke: resolveColor(dotStyle?.dotStroke, point),
-        }}
-      />
-    </g>
-  {/each}
-  {#if showLabels}
-    {#each data as point (`${point.series ?? ''}_${point.x}_${point.y}`)}
-      <g transform="translate({point.dx ?? 0}, {point.dy ?? 0})">
-        <TextMarker
-          data={[point]}
-          x={(d) => d.x}
-          y={(d) => d.y}
-          text={(d) => format ? format(d) : (d.label ?? '')}
-          style={resolveFontStyle(point)}
-        />
-      </g>
-    {/each}
-  {/if}
-{/if}

package/dist/markers/LineMarker.svelte

@@ -1,19 +0,0 @@
-<script lang="ts">
-  import { Line } from 'svelteplot';
-  import type { LineMarkerConfig } from '../types/markers/common';
-
-  /** Renders one `'line'` marker as a `<Line>` call — just the stroke. Endpoint dots are a separate `'dot'` marker. */
-  let { marker }: { marker: LineMarkerConfig } = $props();
-</script>
-
-<Line
-  data={marker.data}
-  x={marker.x}
-  y={marker.y}
-  stroke={marker.style?.stroke}
-  strokeWidth={marker.style?.strokeWidth}
-  strokeOpacity={marker.style?.strokeOpacity}
-  strokeDasharray={marker.style?.strokeDasharray}
-  strokeLinejoin={marker.style?.strokeLinejoin}
-  strokeLinecap={marker.style?.strokeLinecap}
-/>

package/dist/markers/LinkMarker.svelte

@@ -1,42 +0,0 @@
-<script lang="ts">
-  import { Geo } from 'svelteplot';
-  import { resolveAccessor } from '../plots/utils/accessors';
-  import { greatCircleInterpolate } from '../plots/utils/geoAccessors';
-  import type { GeoLinkMarkerConfig } from '../types/markers/geo';
-
-  /** Renders one `'link'` marker — geodesic-aware lines between point pairs, as a synthetic `LineString` fed through `<Geo>`. */
-  let { marker }: { marker: GeoLinkMarkerConfig } = $props();
-
-  const getX1 = $derived(resolveAccessor(marker.x1));
-  const getY1 = $derived(resolveAccessor(marker.y1));
-  const getX2 = $derived(resolveAccessor(marker.x2));
-  const getY2 = $derived(resolveAccessor(marker.y2));
-
-  const linkFeatures = $derived(
-    marker.data.map((d) => ({
-      type: 'Feature' as const,
-      properties: {},
-      geometry: {
-        type: 'LineString' as const,
-        coordinates:
-          marker.curve === 'linear'
-            ? [
-                [Number(getX1(d)), Number(getY1(d))],
-                [Number(getX2(d)), Number(getY2(d))],
-              ]
-            : greatCircleInterpolate(Number(getX1(d)), Number(getY1(d)), Number(getX2(d)), Number(getY2(d))),
-      },
-    })),
-  );
-</script>
-
-<!-- No `fill` prop: svelteplot treats any string as scale-worthy unless it's a real CSS color, so a literal `'none'` would run through the color scale instead of staying unfilled. Omitting it leaves svelteplot's own unfilled default in place. -->
-<Geo
-  class="link"
-  data={linkFeatures}
-  stroke={marker.style?.stroke ?? 'currentColor'}
-  strokeWidth={marker.style?.strokeWidth ?? 1}
-  strokeOpacity={marker.style?.strokeOpacity}
-  strokeDasharray={marker.style?.strokeDasharray}
-  style="vector-effect: non-scaling-stroke"
-/>