@fundar/data-chart-telling 0.0.25 → 0.0.27

package/dist/plots/utils/segments.js

@@ -35,22 +35,6 @@ function areaMatchesXY(xVal, yVal, area) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         (area.y.to === undefined || yVal <= area.y.to);
 }
-/**
- * For each segment in `segs`, returns the subset of `data` rows whose x value
- * (from `xAccessor`) falls inside any of the segment's x ranges. Rows are
- * not deduplicated across segments — a row that matches multiple segments
- * appears in each resulting array.
- *
- * Used by component and hover markers with the `'segment'` strategy.
- */
-export function getDataForSegments(data, xAccessor, segs) {
-    return segs.map((seg) => {
-        const areas = seg.areas;
-        if (!areas || areas.length === 0)
-            return data;
-        return data.filter((d) => areas.some((area) => areaMatchesX(xAccessor(d), area)));
-    });
-}
 /**
  * Warns about obvious configuration mistakes: multiple catch-all segments
  * (no `areas`) in the same series list. Since catch-alls are evaluated last
@@ -209,3 +193,29 @@ export function buildGroupedSeries(seriesList, segments, connect = true) {
         visualSegments: resolveSeriesSegments(s, resolveSegmentsForSeries(segments, s.name), connect),
     }));
 }
+/**
+ * Builds the `ScopedMarkerGroup[]` a `Plot.svelte` hands to `GeometryLayout`
+ * for rendering `series`-scoped `hover`/`component` markers — one group per
+ * series, carrying its resolved segments' match predicates and colors.
+ * `colorFor` resolves a series' own default color; `segmentColorFor` reads
+ * whichever field counts as "color" out of that plot kind's segment style
+ * shape (e.g. `fill` vs `stroke.stroke`), since that's the only part of this
+ * that isn't shared across plot kinds.
+ */
+export function buildScopedMarkerGroups(args) {
+    const { groupedSeries, segments, colorFor, segmentColorFor } = args;
+    return groupedSeries.map((group, seriesIndex) => {
+        const defaultColor = colorFor(group.series, seriesIndex);
+        const xFor = resolveAccessor(group.series.x);
+        const segs = resolveSegmentsForSeries(segments, group.series.name);
+        return {
+            name: group.series.name,
+            data: group.series.data,
+            color: defaultColor,
+            segments: segs.map((seg) => ({
+                match: (row) => matchesSegmentX(xFor(row), seg),
+                color: segmentColorFor(seg.style, defaultColor),
+            })),
+        };
+    });
+}

package/dist/types/charts/common.d.ts

@@ -1,66 +1,19 @@
 import type { Snippet } from 'svelte';
-import type { AxisValue } from '../plots/axis';
-import type { Accessor } from '../plots/data/common';
-import type { EasingName, EasingFn } from './interpolate';
-export type TimeValue = number;
-export type Orientation = 'horizontal' | 'vertical';
-export type FacetColumns = number | {
-    desktop: number;
-    mobile: number;
-};
+import type { TimeValue } from '../layout/timeline';
+import type { LegendPlotContext } from '../layout/legend';
 export type ChartBoxContext = {
     width: number;
     height: number;
 };
 export type ChartBoxSnippet = Snippet<[ChartBoxContext]>;
-export type FacetCellContext<TRow extends Record<string, unknown>> = {
-    facetValue: string;
-    data: TRow[];
-    width: number;
-    height: number;
-};
-export type FacetCellSnippet<TRow extends Record<string, unknown>> = Snippet<[
-    FacetCellContext<TRow>
-]>;
-export type TimelineChildContext<TRow extends Record<string, unknown>> = {
-    selectedValue: TimeValue;
-    data: TRow[];
-    width: number;
-    height: number;
-};
-export type TimelineChildSnippet<TRow extends Record<string, unknown>> = Snippet<[
-    TimelineChildContext<TRow>
-]>;
 export type ChartPlotContext<TRow extends Record<string, unknown>> = {
     data: TRow[];
     width: number;
     height: number;
     facetValue?: string;
     selectedValue?: TimeValue;
+    legend?: LegendPlotContext;
 };
 export type ChartPlotSnippet<TRow extends Record<string, unknown>> = Snippet<[
     ChartPlotContext<TRow>
 ]>;
-export type TimelineInterpolation<TRow extends Record<string, unknown>> = {
-    key?: Accessor<TRow, unknown>;
-    value?: Accessor<TRow, AxisValue>;
-    create?: (lower: TRow, upper: TRow, x: TimeValue, value: number) => TRow;
-    progressEasing?: EasingName | EasingFn;
-    segmentEasing?: EasingName | EasingFn;
-};
-export type TimelineConfig<TRow extends Record<string, unknown>> = {
-    accessor: Accessor<TRow, TimeValue>;
-    progress: number;
-    values?: TimeValue[];
-    orientation?: Orientation;
-    show?: boolean;
-    thickness?: number;
-    filterMode?: 'exact' | 'upTo';
-    interpolate?: boolean | TimelineInterpolation<TRow>;
-};
-export type FacetConfig<TRow extends Record<string, unknown>> = {
-    by: Accessor<TRow, unknown>;
-    columns?: FacetColumns;
-    values?: string[];
-    gap?: number;
-};

package/dist/types/charts/props.d.ts

@@ -1,13 +1,13 @@
 import type { Snippet } from 'svelte';
-import type { AxisValue } from '../plots/axis';
+import type { AxisValue, AxisBasedScalesConfig } from '../layout/scales';
 import type { Accessor } from '../plots/data/common';
-import type { AxisBasedScalesConfig } from '../plots/props';
-import type { BasePlotStyles } from '../plots/styles/common';
+import type { BasePlotStylesConfig } from '../layout/styles';
 import type { SegmentsConfig, MarginConfig } from '../plots/props';
-import type { Marker } from '../markers/common';
+import type { AxisBasedMarkersConfig } from '../markers/common';
 import type { TooltipProp } from '../layout/tooltip';
-import type { LegendSection } from './legend';
-import type { FacetConfig, TimelineConfig } from './common';
+import type { LegendSection } from '../layout/legend';
+import type { FacetConfig } from '../layout/facet';
+import type { TimelineConfig } from '../layout/timeline';
 /**
  * Common props accepted by every chart component (bar, line, heatmap, pyramid,
  * …). The `TSegmentStyle` parameter lets each chart narrow `segments` to its
@@ -30,9 +30,9 @@ export type ChartProps<TRow extends Record<string, unknown>, TSegmentStyle exten
     x: Accessor<TRow, AxisValue>;
     y: Accessor<TRow, AxisValue>;
     z?: Accessor<TRow, unknown>;
-    styles?: BasePlotStyles;
+    styles?: BasePlotStylesConfig;
     segments?: SegmentsConfig<TSegmentStyle>;
-    markers?: Marker[];
+    markers?: AxisBasedMarkersConfig[];
     scales?: AxisBasedScalesConfig<TRow>;
     margins?: MarginConfig;
     facet?: FacetConfig<TRow>;

package/dist/types/configuration/styling.d.ts

@@ -1,4 +1,4 @@
-import type { StrokeStyle, DotStyle, FontStyle } from '../plots/styling';
+import type { StrokeStyle, DotStyle, FontStyle, AreaStyle } from '../plots/styling';
 export type TextStyle = {
     /** font-family */
     font: string;
@@ -101,17 +101,41 @@ export type ChartConfig = {
             connectorWidth: number;
         };
     };
+    /** Default scatter point geometry. */
+    scatter: {
+        dotRadius: number;
+    };
     /** Timeline gutter styling. */
     timeline: {
         axisColor: string;
         activeColor: string;
         thickness: number;
     };
-    /** In-SVG hover highlight (crosshair rule, dot, and value label). */
+    /** In-SVG hover highlight: crosshair rule, dot + value label, and geo feature restyle. */
     hover: {
         rule: StrokeStyle;
         dot: DotStyle;
         font: FontStyle;
+        area: AreaStyle;
+    };
+    facet: {
+        /** Position badge shown in `carousel`/`paginated` facet modes. */
+        indicator: {
+            background: string;
+            color: string;
+            fontSize: string;
+            padding: string;
+            radius: string;
+        };
+        /** Prev/next buttons shown in `paginated` facet mode. */
+        navButton: {
+            background: string;
+            color: string;
+            /** Button diameter (width and height). */
+            size: string;
+            fontSize: string;
+            disabledOpacity: number;
+        };
     };
 };
 /** Deep-partial input accepted by `setConfiguration`. */

package/dist/types/{plots/scales/geo.d.ts → layout/coordinates.d.ts}

@@ -1,10 +1,10 @@
+import type { GeoProjection } from 'd3-geo';
 /**
  * The projection names svelteplot's `<Plot projection>` accepts as a string
  * (svelteplot itself doesn't export this as a type — defined here so authors
  * get autocomplete/type-checking over the full supported set).
  */
 export type GeoProjectionName = 'albers-usa' | 'albers' | 'azimuthal-equal-area' | 'azimuthal-equidistant' | 'conic-conformal' | 'conic-equal-area' | 'conic-equidistant' | 'equal-earth' | 'equirectangular' | 'gnomonic' | 'identity' | 'reflect-y' | 'mercator' | 'orthographic' | 'stereographic' | 'transverse-mercator';
-import type { GeoProjection } from 'd3-geo';
 /**
  * What a custom projection factory (e.g. `argentinaBicontinental` under
  * `$lib`'s geo projections) must return — just enough of d3's `GeoProjection`
@@ -42,3 +42,35 @@ export type GeoProjectionConfig = GeoProjectionName | {
      */
     domain?: GeoJSON.GeoJsonObject | GeoJSON.FeatureCollection | GeoJSON.Feature | 'data';
 };
+/**
+ * `scales` prop for GeoPlot — the geo analog of `AxisBasedScalesConfig`.
+ * A map has no x/y/z axis pair, so this only configures the choropleth
+ * colour domain (the coordinate system itself is `coordinates.projection`).
+ */
+export type GeoScalesConfig = {
+    /** Continuous choropleth value domain — mirrors heatmap's `scales.z.domain`. */
+    color?: {
+        domain?: [number, number];
+    };
+};
+export type GeoZoomConfig = {
+    min?: number;
+    max?: number;
+    initial?: {
+        x?: number;
+        y?: number;
+        k?: number;
+    };
+};
+/**
+ * `coordinates` prop for GeoPlot — the only plot kind with a coordinate
+ * system other than implicit cartesian. Bundles the projection (a `GoG`
+ * Coordinates concern) and pan/zoom (navigating within that coordinate
+ * system), resolved together by `CoordinatesLayout`.
+ */
+export type CoordinatesConfig = {
+    /** Which map projection to draw with. Defaults to `'equal-earth'`. */
+    projection?: GeoProjectionConfig;
+    /** `true`/config enables drag-pan + scroll-zoom. Omitted/`false` = static map. */
+    zoom?: boolean | GeoZoomConfig;
+};

package/dist/types/layout/facet.d.ts

@@ -0,0 +1,41 @@
+import type { Snippet } from 'svelte';
+import type { Accessor } from '../plots/data/common';
+export type Responsive<T> = T | {
+    desktop: T;
+    mobile: T;
+};
+export type FacetColumns = Responsive<number>;
+export type FacetMode = 'grid' | 'carousel' | 'paginated';
+export type FacetCellContext<TRow extends Record<string, unknown>> = {
+    facetValue: string;
+    data: TRow[];
+    width: number;
+    height: number;
+};
+export type FacetCellSnippet<TRow extends Record<string, unknown>> = Snippet<[
+    FacetCellContext<TRow>
+]>;
+export type FacetIndicatorContext = {
+    current: number;
+    total: number;
+};
+export type FacetIndicatorSnippet = Snippet<[FacetIndicatorContext]>;
+export type FacetNavDirection = 'prev' | 'next';
+export type FacetNavContext = {
+    direction: FacetNavDirection;
+    disabled: boolean;
+    onclick: () => void;
+};
+export type FacetNavSnippet = Snippet<[FacetNavContext]>;
+export type FacetConfig<TRow extends Record<string, unknown>> = {
+    by: Accessor<TRow, unknown>;
+    columns?: FacetColumns;
+    values?: string[];
+    gap?: number;
+    mode?: Responsive<FacetMode>;
+    visible?: number;
+    pageSize?: number;
+    formatIndicator?: (current: number, total: number) => string;
+    indicator?: FacetIndicatorSnippet;
+    navButton?: FacetNavSnippet;
+};

package/dist/types/layout/geometry.d.ts

@@ -0,0 +1,17 @@
+/** One resolved segment for scoped-marker rendering — see {@link ScopedMarkerGroup}. */
+export type ScopedMarkerSegment<TData> = {
+    match: (row: TData) => boolean;
+    color: string;
+};
+/**
+ * One series' resolved context for rendering its `series`-scoped `'hover'`/
+ * `'component'` markers — built by each `Plot.svelte`, consumed by
+ * `GeometryLayout`. Keeps `GeometryLayout` itself agnostic of each plot
+ * kind's segment style shape (e.g. `fill` vs `stroke.stroke`).
+ */
+export type ScopedMarkerGroup<TData> = {
+    name: string;
+    data: TData[];
+    color: string;
+    segments: ScopedMarkerSegment<TData>[];
+};

package/dist/types/layout/legend.d.ts

@@ -1,5 +1,64 @@
 import type { SvelteMap } from 'svelte/reactivity';
-import type { LegendDisabledStyle } from '../charts/legend';
+import type { SymbolType, LineStyle } from '../plots/constants';
+import type { StrokeStyle, DotStyle } from '../plots/styling';
+export type LegendSectionType = 'discrete' | 'continuous';
+/**
+ * Style applied to whatever a legend interaction has turned "off" — a
+ * toggled-off discrete series, or a datapoint/cell/feature outside an active
+ * continuous range filter. `opacity` is a blanket convenience: any
+ * `*Opacity` field a consumer doesn't set falls back to it, so
+ * `{ opacity: 0.1 }` alone is enough to read as "disabled" everywhere.
+ */
+export type LegendDisabledStyle = {
+    opacity?: number;
+    stroke?: StrokeStyle;
+    dots?: DotStyle;
+    fill?: string;
+    fillOpacity?: number;
+};
+export type LegendItem = {
+    name: string;
+    label?: string;
+    color?: string;
+    symbol?: SymbolType;
+    opacity?: number;
+    lineStyle?: LineStyle;
+    /** Initial toggled-off state (uncontrolled — the user can still click it back on). */
+    disabled?: boolean;
+};
+export type DiscreteLegendSection = {
+    type: 'discrete';
+    title?: string;
+    items: LegendItem[];
+    columns?: number;
+    /** Enables click-to-toggle on each item. */
+    interactive?: boolean;
+    /** Style applied to a toggled-off item's series. Falls back to `cfg.legend.disabledOpacity`. */
+    disabledStyle?: LegendDisabledStyle;
+};
+export type ContinuousLegendSection = {
+    type: 'continuous';
+    title?: string;
+    columns?: number;
+    min: number;
+    max: number;
+    colorMin?: string;
+    colorMax?: string;
+    ticks?: number[];
+    width?: number;
+    format?: (v: number) => string;
+    /** Enables drag handles on the bar's edges to narrow the visible range. */
+    interactive?: boolean;
+    /**
+     * How the color ramp responds to a narrowed range: `'rescale'` reprojects
+     * it onto the new bounds, `'filter'` keeps the original domain and only
+     * excludes out-of-range values. Defaults to `'filter'`.
+     */
+    mode?: 'rescale' | 'filter';
+    /** Style applied to values outside the active range. Falls back to `cfg.legend.disabledOpacity`. */
+    disabledStyle?: LegendDisabledStyle;
+};
+export type LegendSection = DiscreteLegendSection | ContinuousLegendSection;
 /**
  * Shared legend-interaction state for cross-cutting legend → plot wiring.
  *
@@ -24,3 +83,8 @@ export type LegendInteractionStore = {
         disabledStyle: LegendDisabledStyle;
     } | null;
 };
+/** Read-only view of which series a legend has toggled off, resolved from {@link BaseChart}'s legend-interaction store. */
+export type LegendPlotContext = {
+    disabledSeries: ReadonlySet<string>;
+    isDisabled: (name: string) => boolean;
+};

package/dist/types/{plots/axis.d.ts → layout/scales.d.ts}

@@ -53,3 +53,14 @@ export type AxisScale<TData = Record<string, unknown>> = {
     seriesLayout?: 'overlap' | 'grouped' | 'stacked';
     seriesPadding?: number;
 };
+/**
+ * Per-axis scale overrides, passed as a single `scales` prop to every
+ * axis-based plot kind (`GeoPlot` uses `GeoScalesConfig` instead — a map has
+ * no x/y/z axis pair). `TData` threads through to {@link AxisScale.sort} on
+ * each axis.
+ */
+export type AxisBasedScalesConfig<TData = Record<string, unknown>> = {
+    x?: AxisScale<TData>;
+    y?: AxisScale<TData>;
+    z?: AxisScale<TData>;
+};

package/dist/types/layout/styles.d.ts

@@ -0,0 +1,115 @@
+import type { ValueAnchor } from '../plots/constants';
+import type { FontStyle, StrokeStyle, AreaStyle } from '../plots/styling';
+import type { GeoFeature } from '../plots/data/geo';
+/**
+ * Controls if and how value labels are rendered on a plot. The high-level
+ * `anchor` sets sensible defaults for placement; `fontStyle` (`dx`, `dy`,
+ * `textAnchor`, `lineAnchor`, `lineHeight`, `rotate`, `class`, `textClass`,
+ * `fill`, …) overrides those defaults field-by-field when provided — mirrors
+ * {@link DeltaConfig}'s `fontStyle`/`strokeStyle` split, so label text and
+ * connector-line styling never mix into one flat bag of props.
+ */
+export type ValuesStyle = {
+    show?: boolean;
+    anchor?: ValueAnchor;
+    format?: (value: number, seriesName: string) => string;
+    hoverIsolate?: boolean;
+    fontStyle?: FontStyle;
+    strokeStyle?: StrokeStyle;
+};
+/**
+ * Color overrides for plots that derive their palette from data.
+ * Each plot uses only the fields relevant to its kind; unused fields are
+ * silently ignored.
+ *
+ * - `min` / `max` — sequential colour ramp endpoints (heatmap).
+ * - `left` / `right` — diverging bar sides (pyramid).
+ */
+export type ColorsStyle = {
+    min?: string;
+    max?: string;
+    left?: string;
+    right?: string;
+};
+/**
+ * Decorative border around the plot's own content box — svelteplot's
+ * `Frame` mark, purely cosmetic (drawn from the box geometry, never from
+ * data). `true` enables it with svelteplot's own defaults; an object
+ * enables it and overrides its look field-by-field. Insets pull the frame
+ * in from the content box's own edges, in pixels.
+ */
+export type FrameStyle = AreaStyle & {
+    inset?: number;
+    insetTop?: number;
+    insetRight?: number;
+    insetBottom?: number;
+    insetLeft?: number;
+};
+/** Author-facing `styles.frame` prop — see {@link FrameStyle}. */
+export type FrameProp = boolean | FrameStyle;
+/**
+ * Top-level rendering style overrides shared by the non-geo plot kinds.
+ * Passed as the `styles` prop. Each plot reads only the fields it cares
+ * about.
+ */
+export type BasePlotStylesConfig = {
+    values?: ValuesStyle;
+    colors?: ColorsStyle;
+    /** Decorative border around the plot's content box — see {@link FrameStyle}. Available on every plot kind. */
+    frame?: FrameProp;
+};
+export type GeoTileLayerConfig = {
+    /** XYZ tile URL template, e.g. `'https://tile.openstreetmap.org/{z}/{x}/{y}.png'`. */
+    url: string;
+    attribution?: string;
+    opacity?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    /** Tile edge length in pixels. Defaults to `256`. */
+    tileSize?: number;
+};
+/**
+ * `styles` prop for GeoPlot — the geo analog of `BasePlotStylesConfig`.
+ * Unlike the other plot kinds, GeoPlot's styling needs (base map, choropleth
+ * ramp, tile background, click handling) are unlike anything x/y plots need,
+ * so this is its own type rather than a reuse of `BasePlotStylesConfig`.
+ */
+export type GeoStylesConfig<TProps extends Record<string, unknown> = Record<string, unknown>> = {
+    /** Base map fill, used when a feature isn't styled by `segments` or the choropleth ramp. */
+    fill?: string;
+    fillOpacity?: number;
+    stroke?: string;
+    strokeWidth?: number;
+    /** Continuous choropleth ramp endpoints — used when `value` is provided on data. Mirrors heatmap's `styles.colors`. */
+    colors?: ColorsStyle;
+    /** Raster XYZ tile basemap under the vector geometry. Mercator-family projections only. */
+    tileLayer?: GeoTileLayerConfig;
+    /** Fired when a base-map feature is clicked. */
+    onFeatureClick?: (feature: GeoFeature<TProps>, event: Event) => void;
+    /** Decorative border around the plot's content box — see {@link FrameStyle}. Available on every plot kind. */
+    frame?: FrameProp;
+};
+/**
+ * `GeoTileLayerConfig`, plus `features` — never author-facing (the public
+ * `styles.tileLayer` shape, {@link GeoTileLayerConfig}, doesn't declare it).
+ * `GeoPlot` tacks it onto its own internal copy of `styles` so `StylesLayout`
+ * can compute the tile layer's auto-fit bounds without needing raw geometry
+ * threaded through as a separate prop.
+ */
+type GeoTileLayerConfigWithFeatures = GeoTileLayerConfig & {
+    features?: {
+        geometry: GeoJSON.Geometry;
+    }[];
+};
+/**
+ * The minimal slice of a plot kind's own `styles` prop `StylesLayout` reads —
+ * every concrete `styles` type ({@link BasePlotStylesConfig},
+ * {@link GeoStylesConfig}) structurally satisfies this whether or not it
+ * declares `tileLayer` at all (a missing optional field type-checks fine).
+ */
+export type StylesLayoutConfig = {
+    tileLayer?: GeoTileLayerConfigWithFeatures;
+    frame?: FrameProp;
+    [key: string]: unknown;
+};
+export {};

package/dist/types/layout/timeline.d.ts

@@ -0,0 +1,32 @@
+import type { Snippet } from 'svelte';
+import type { AxisValue } from './scales';
+import type { Accessor } from '../plots/data/common';
+import type { EasingName, EasingFn } from '../charts/interpolate';
+export type TimeValue = number;
+export type Orientation = 'horizontal' | 'vertical';
+export type TimelineChildContext<TRow extends Record<string, unknown>> = {
+    selectedValue: TimeValue;
+    data: TRow[];
+    width: number;
+    height: number;
+};
+export type TimelineChildSnippet<TRow extends Record<string, unknown>> = Snippet<[
+    TimelineChildContext<TRow>
+]>;
+export type TimelineInterpolation<TRow extends Record<string, unknown>> = {
+    key?: Accessor<TRow, unknown>;
+    value?: Accessor<TRow, AxisValue>;
+    create?: (lower: TRow, upper: TRow, x: TimeValue, value: number) => TRow;
+    progressEasing?: EasingName | EasingFn;
+    segmentEasing?: EasingName | EasingFn;
+};
+export type TimelineConfig<TRow extends Record<string, unknown>> = {
+    accessor: Accessor<TRow, TimeValue>;
+    progress: number;
+    values?: TimeValue[];
+    orientation?: Orientation;
+    show?: boolean;
+    thickness?: number;
+    filterMode?: 'exact' | 'upTo';
+    interpolate?: boolean | TimelineInterpolation<TRow>;
+};

package/dist/types/layout/tooltip.d.ts

@@ -1,5 +1,5 @@
 import type { Snippet } from 'svelte';
-import type { AxisValue } from '../plots/axis';
+import type { AxisValue } from './scales';
 /**
  * How the hover highlight finds related points within a facet.
  * - `'x'` all points sharing the hovered x (default for line / bar).
@@ -7,6 +7,21 @@ import type { AxisValue } from '../plots/axis';
  * - `'punctual'` exact XY match — one cell at a time (default for heatmap).
  */
 export type HoverStrategy = 'x' | 'y' | 'punctual';
+/**
+ * Preferred horizontal placement of the floating tooltip relative to the
+ * cursor: `'right'`/`'left'` offset it clear of the cursor (so it never
+ * covers the hovered point); `'middle'` centers it on the cursor's x, same
+ * as the plot's own vertical `'middle'`. Falls back toward the opposite
+ * side (via `'middle'`) when the preferred side would overflow the plot's
+ * bounds — see {@link resolveTooltipPlacement}. System default: `'right'`.
+ */
+export type TooltipAnchorX = 'left' | 'middle' | 'right';
+/**
+ * Preferred vertical placement of the floating tooltip relative to the
+ * cursor — same fallback behavior as {@link TooltipAnchorX}, along the other
+ * axis. System default: `'bottom'`.
+ */
+export type TooltipAnchorY = 'top' | 'middle' | 'bottom';
 /** Author-facing tooltip option on the chart kinds. `true` = enable with defaults. */
 export type TooltipOptions<TRow extends Record<string, unknown>> = {
     /** Matching strategy. Defaults to the chart kind's own default. */
@@ -24,6 +39,10 @@ export type TooltipOptions<TRow extends Record<string, unknown>> = {
     content?: Snippet<[{
         rows: TRow[];
     }]>;
+    /** Preferred horizontal anchor — see {@link TooltipAnchorX}. */
+    anchorX?: TooltipAnchorX;
+    /** Preferred vertical anchor — see {@link TooltipAnchorY}. */
+    anchorY?: TooltipAnchorY;
 };
 /** Either a bare on/off flag or the full option object. */
 export type TooltipProp<TRow extends Record<string, unknown>> = boolean | TooltipOptions<TRow>;

package/dist/types/markers/all.d.ts

@@ -0,0 +1,11 @@
+import type { AxisBasedMarkersConfig } from './common';
+import type { GeoMarkersConfig, GeoFeaturesMarkerConfig } from './geo';
+import type { LineMarkersConfig } from './line';
+/**
+ * Every marker kind `GeometryLayout`/`BasePlotLayout` can route to — the
+ * union of every plot kind's own `markers` prop type, plus
+ * `GeoFeaturesMarkerConfig` (built internally, never author-facing). Not
+ * used as any `Plot.svelte`'s own `TMarker` — see each kind's own precise
+ * type instead.
+ */
+export type MarkerConfig = AxisBasedMarkersConfig | LineMarkersConfig | GeoMarkersConfig | GeoFeaturesMarkerConfig;

package/dist/types/markers/all.js

@@ -0,0 +1 @@
+export {};

package/dist/types/markers/base.d.ts

@@ -0,0 +1,45 @@
+import type { AxisValue } from '../layout/scales';
+import type { DotStyle, FontStyle } from '../plots/styling';
+import type { ColorsStyle } from '../layout/styles';
+/**
+ * A set of point marks (svelteplot's `Dot`) — usable on any plot kind, axis-based or geo.
+ *
+ * `x`/`y`/`r`/`value` accept a field key or an accessor function, like `Series.x`/`y`.
+ * `GeometryLayout` resolves the shorthand before it reaches `DotMarker.svelte`, which only
+ * ever sees functions.
+ */
+export type DotMarkerConfig = {
+    type: 'dot';
+    data: Record<string, unknown>[];
+    x: string | ((d: any) => AxisValue);
+    y: string | ((d: any) => AxisValue);
+    /** Per-row radius, or a constant — overrides `style.dotRadius`. */
+    r?: number | string | ((d: any) => number);
+    /** Per-row fill, overriding `style.dotFill` — ignored when `value` is set. */
+    fill?: (d: any) => string;
+    /** Continuous value driving a per-dot color ramp through `style.colors`. */
+    value?: string | ((d: any) => number);
+    style?: DotStyle & {
+        colors?: ColorsStyle;
+    };
+};
+/**
+ * A text label per row (svelteplot's `Text`) — usable on any plot kind, axis-based or geo.
+ *
+ * `x`/`y` accept the same field-key-or-function shorthand as `DotMarkerConfig`. `text` is a
+ * constant or a per-row accessor.
+ */
+export type TextMarkerConfig = {
+    type: 'text';
+    data: Record<string, unknown>[];
+    x: string | ((d: any) => AxisValue);
+    y: string | ((d: any) => AxisValue);
+    text: string | ((d: any) => string);
+    style?: FontStyle;
+};
+/**
+ * Every marker kind usable on any plot, axis-based or geo. `AxisBasedMarkersConfig`
+ * (`types/markers/common.ts`) and `GeoMarkersConfig` (`types/markers/geo.ts`) both extend
+ * this, so `MarkerConfig` (`types/markers/all.ts`) can union the two without a shape collision.
+ */
+export type BaseMarkersConfig = DotMarkerConfig | TextMarkerConfig;

package/dist/types/markers/base.js

@@ -0,0 +1 @@
+export {};