@fundar/data-chart-telling 0.0.14 → 0.0.16

package/dist/plots/utils/topojson.js

@@ -0,0 +1,30 @@
+export function isTopology(data) {
+    return !!data && typeof data === 'object' && data.type === 'Topology';
+}
+/**
+ * Converts a TopoJSON `Topology` to GeoJSON via `topojson-client`'s
+ * `feature()`, loaded with a dynamic import so the package works perfectly
+ * for consumers who never install `topojson-client` — it's an optional peer
+ * dependency (see package.json), never statically imported.
+ */
+export async function topologyToGeoJson(topology, object) {
+    const obj = topology.objects[object];
+    if (!obj) {
+        throw new Error(`GeoPlot: topology.objects has no key "${object}".`);
+    }
+    let mod;
+    try {
+        // @ts-expect-error — topojson-client is an optional peer dependency; its
+        // type declarations are intentionally not resolved by our own build
+        // (`Topology` above is typed structurally instead), so this import is
+        // resolved purely at runtime.
+        mod = await import('topojson-client');
+    }
+    catch {
+        throw new Error("GeoPlot: `data` is a TopoJSON Topology, but 'topojson-client' isn't installed. " +
+            'Run `npm install topojson-client` (it\'s an optional peer dependency) or pass GeoJSON directly.');
+    }
+    const { feature } = mod;
+    const collection = feature(topology, obj);
+    return (collection.type === 'FeatureCollection' ? collection.features : [collection]);
+}

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

@@ -1,5 +1,6 @@
 import type { Snippet } from 'svelte';
-import type { Accessor, AxisValue } from '../plots/common';
+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';

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

@@ -1,5 +1,20 @@
-import type { SymbolType, LineStyle } from '../plots/styles';
+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;
@@ -7,12 +22,18 @@ export type LegendItem = {
     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';
@@ -25,5 +46,15 @@ export type ContinuousLegendSection = {
     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;

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

@@ -1,7 +1,10 @@
 import type { Snippet } from 'svelte';
-import type { Accessor, AxisValue, ScalesConfig, MarginConfig } from '../plots/common';
-import type { PlotStyles, Segments } from '../plots/styles';
-import type { Marker } from '../plots/markers';
+import type { AxisValue } from '../plots/axis';
+import type { Accessor } from '../plots/data/common';
+import type { AxisBasedScalesConfig } from '../plots/props';
+import type { BasePlotStyles } from '../plots/styles/common';
+import type { SegmentsConfig, MarginConfig } from '../plots/props';
+import type { Marker } from '../markers/common';
 import type { TooltipProp } from '../layout/tooltip';
 import type { LegendSection } from './legend';
 import type { FacetConfig, TimelineConfig } from './common';
@@ -27,10 +30,10 @@ export type ChartProps<TRow extends Record<string, unknown>, TSegmentStyle exten
     x: Accessor<TRow, AxisValue>;
     y: Accessor<TRow, AxisValue>;
     z?: Accessor<TRow, unknown>;
-    styles?: PlotStyles;
-    segments?: Segments<TSegmentStyle>;
+    styles?: BasePlotStyles;
+    segments?: SegmentsConfig<TSegmentStyle>;
     markers?: Marker[];
-    scales?: ScalesConfig;
+    scales?: AxisBasedScalesConfig<TRow>;
     margins?: MarginConfig;
     facet?: FacetConfig<TRow>;
     timeline?: TimelineConfig<TRow>;

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

@@ -1,4 +1,4 @@
-import type { StrokeStyle, DotStyle, FontStyle } from '../plots/styles';
+import type { StrokeStyle, DotStyle, FontStyle } from '../plots/styling';
 export type TextStyle = {
     /** font-family */
     font: string;
@@ -37,6 +37,8 @@ export type ChartConfig = {
         gap: string;
         /** swatch square size */
         swatchSize: string;
+        /** Fallback opacity for a legend-disabled series/value when a section doesn't set its own `disabledStyle`. */
+        disabledOpacity: number;
     };
     axis: {
         color: string;
@@ -57,11 +59,17 @@ export type ChartConfig = {
         radius: string;
         border: string;
     };
+    /**
+     * Per-side plot margin. `'auto'` (the default) lets svelteplot size that
+     * side to fit whatever it actually renders there — tick labels, an axis
+     * title, rotated ticks — instead of clipping content or leaving unused
+     * space. A number pins that side exactly, opting out of auto-sizing.
+     */
     margins: {
-        top: number;
-        right: number;
-        bottom: number;
-        left: number;
+        top: number | 'auto';
+        right: number | 'auto';
+        bottom: number | 'auto';
+        left: number | 'auto';
     };
     /** Discrete categorical palette (grouped series). */
     palette: string[];

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

@@ -0,0 +1,26 @@
+import type { SvelteMap } from 'svelte/reactivity';
+import type { LegendDisabledStyle } from '../charts/legend';
+/**
+ * Shared legend-interaction state for cross-cutting legend → plot wiring.
+ *
+ * {@link BaseChart} provides one store via context (mirrors {@link HoverStore});
+ * `DiscreteSection`/`ContinuousSection` write to it on click/drag, and every
+ * plot kind (line/bar/pyramid/heatmap/geo) reads the same instance to know
+ * what to dim. A standalone legend/plot with no provider falls back to its
+ * own private store via `createLegendInteraction`.
+ */
+export type LegendInteractionStore = {
+    /** Legend item name → resolved style to apply. Presence in the map means "disabled". */
+    disabledSeries: SvelteMap<string, LegendDisabledStyle>;
+    /**
+     * The active drag state of the (first) interactive continuous section, or
+     * `null` when none is interactive or the user hasn't narrowed it yet (full
+     * range — nothing hidden).
+     */
+    continuousRange: {
+        min: number;
+        max: number;
+        mode: 'rescale' | 'filter';
+        disabledStyle: LegendDisabledStyle;
+    } | null;
+};

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

@@ -1,9 +1,9 @@
 import type { Snippet } from 'svelte';
-import type { AxisValue } from '../plots/common';
+import type { AxisValue } from '../plots/axis';
 /**
  * How the hover highlight finds related points within a facet.
- * - `'x'`        all points sharing the hovered x (default for line / bar).
- * - `'y'`        all points sharing the hovered y (default for pyramid).
+ * - `'x'` all points sharing the hovered x (default for line / bar).
+ * - `'y'` all points sharing the hovered y (default for pyramid).
  * - `'punctual'` exact XY match — one cell at a time (default for heatmap).
  */
 export type HoverStrategy = 'x' | 'y' | 'punctual';
@@ -27,27 +27,10 @@ export type TooltipOptions<TRow extends Record<string, unknown>> = {
 };
 /** Either a bare on/off flag or the full option object. */
 export type TooltipProp<TRow extends Record<string, unknown>> = boolean | TooltipOptions<TRow>;
-/**
- * Resolved tooltip config handed from a chart kind down to a plot. Presence of
- * this object on a plot is what turns hovering on.
- */
-export type TooltipRuntime<TRow extends Record<string, unknown>> = {
-    format: (row: TRow) => string;
-    /** Identifies the originating facet (`''` when not faceted). */
-    facetId: string;
-    /** Strategy resolved by the chart; omitted → PlotLayout falls back to its own default. */
-    strategy?: HoverStrategy;
-    /** Whether to broadcast to other facets. */
-    sync: boolean;
-    series?: string[];
-    content?: Snippet<[{
-        rows: TRow[];
-    }]>;
-};
 /**
  * Shared hover state for cross-facet tooltip syncing.
  *
- * {@link Chart} provides one store via context; every faceted plot reads the
+ * {@link BaseChart} provides one store via context; every faceted plot reads the
  * same instance, so a hover detected in one facet (which writes `activeX/Y` and
  * stamps itself as `source`) is visible to the others. A standalone plot with no
  * provider falls back to its own {@link createHover} store.
@@ -83,6 +66,16 @@ export type HoverDisplayPoint = {
     series?: string;
     /** Resolved series color — used by HoverMarker when dotFill/fill is `'currentColor'`. */
     color?: string;
+    /**
+     * Pixel nudge applied on top of the scaled `x`/`y` position — for plot kinds
+     * where a series' visual position isn't fully captured by its data value
+     * (e.g. BarPlot's 'grouped' layout, where every series shares the same `x`
+     * category but is drawn at its own pixel slice within that category's band).
+     * Matching (`matchByStrategy`) still compares raw `x`/`y`, so this is
+     * display-only and never affects which points highlight together.
+     */
+    dx?: number;
+    dy?: number;
 };
 /** A candidate point for hover matching/highlighting — also carries its source row. */
 export type HoverPoint<T> = HoverDisplayPoint & {

package/dist/types/{plots/markers.d.ts → markers/common.d.ts}

@@ -1,17 +1,6 @@
-import type { AxisValue } from './common';
-import type { DotStyle, FontStyle, StrokeStyle } from './styles';
+import type { AxisValue } from '../plots/axis';
+import type { DotStyle, FontStyle, StrokeStyle } from '../plots/styling';
 import type { HoverStrategy, HoverDisplayPoint } from '../layout/tooltip';
-/**
- * Baseline props every marker component receives when mounted by a plot:
- * `data` for the points/values it draws, plus `series`/`seriesColor` when
- * mounted per-series via a `CustomComponentMarker`. Marker components extend
- * this with whatever else they need (e.g. PeakMarker's `mode`, `label`).
- */
-export interface MarkerProps<TData = Record<string, unknown>> {
-    data?: TData[];
-    series?: string;
-    seriesColor?: string;
-}
 export type RuleXMarker = {
     type: 'ruleX';
     x: AxisValue;
@@ -31,16 +20,12 @@ export type RuleYMarker = {
 export type HoverMarkerConfig = {
     type: 'hover';
     series?: string;
-    /** Whether to render per segment or for the full series. Defaults to `'series'`. */
     scope?: 'series' | 'segment';
-    /** Matching strategy — how related points are found. Defaults to the plot kind's own default. */
     strategy?: HoverStrategy;
-    /** Broadcast the hover to other facets. Defaults to `false`. */
     sync?: boolean;
     ruleX?: boolean;
     ruleY?: boolean;
     showLabels?: boolean;
-    /** Custom label formatter. Receives the matched point; return the string to display. */
     format?: (point: HoverDisplayPoint) => string;
     ruleStyle?: StrokeStyle;
     dotStyle?: DotStyle;
@@ -52,7 +37,6 @@ export type CustomComponentMarker = {
     component: any;
     props?: Record<string, unknown>;
     data?: any[];
-    /** Whether to render per segment or for the full series. Defaults to `'series'`. */
     scope?: 'series' | 'segment';
 };
 export type Marker = RuleXMarker | RuleYMarker | HoverMarkerConfig | CustomComponentMarker;

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

@@ -0,0 +1,237 @@
+import type { Snippet } from 'svelte';
+import type { Accessor } from '../plots/data/common';
+import type { ColorsStyle } from '../plots/styles/common';
+import type { DotStyle, FontStyle, StrokeStyle } from '../plots/styling';
+import type { HoverDisplayPoint } from '../layout/tooltip';
+import type { GeoFeature, GeoJsonInput } from '../plots/data/geo';
+import type { GeoSegmentStyle } from '../plots/segments/common';
+import type { GeoProjectionName } from '../plots/scales/geo';
+/** Longitude/latitude gridlines — svelteplot's `Graticule`. */
+export type GeoGraticuleMarker = {
+    type: 'graticule';
+    step?: number;
+    stepX?: number;
+    stepY?: number;
+    style?: StrokeStyle;
+    /**
+     * Renders behind the base map's own fill/stroke instead of on top of it
+     * (markers otherwise always draw over the base map, regardless of their
+     * position in the `markers` array). Useful for a graticule meant to read
+     * as a faint background reference frame rather than an overlay obscuring
+     * the geometry above it.
+     */
+    behind?: boolean;
+};
+/** The outer globe outline (for orthographic-type projections) — svelteplot's `Sphere`. */
+export type GeoSphereMarker = {
+    type: 'sphere';
+    style?: StrokeStyle & {
+        fill?: string;
+        fillOpacity?: number;
+    };
+    /**
+     * Renders behind the base map's own fill/stroke instead of on top of it —
+     * needed any time `style.fill` is set, since a filled sphere otherwise
+     * covers every feature drawn under it (the sphere is the full globe
+     * outline, larger than any geometry on it). Off by default so an
+     * unfilled/stroke-only sphere (the common case, tracing just the globe's
+     * edge) keeps drawing on top where it stays visible over ocean fills.
+     */
+    behind?: boolean;
+};
+/**
+ * Point markers by longitude/latitude, sized/colored by value —
+ * svelteplot's `Dot`. https://svelteplot.dev/examples/dot/weather
+ */
+export type GeoDotMarker<TRow extends Record<string, unknown> = Record<string, unknown>> = {
+    type: 'dot';
+    data: TRow[];
+    x: Accessor<TRow, number>;
+    y: Accessor<TRow, number>;
+    r?: Accessor<TRow, number> | number;
+    /** Continuous value used to color each dot through a ramp — see `style.colors`. */
+    value?: Accessor<TRow, number>;
+    style?: DotStyle & {
+        colors?: ColorsStyle;
+    };
+};
+/**
+ * Arrows/spikes at points — svelteplot's `Vector`.
+ * https://svelteplot.dev/examples/vector/shift-map
+ */
+export type GeoVectorMarker<TRow extends Record<string, unknown> = Record<string, unknown>> = {
+    type: 'vector';
+    data: TRow[];
+    x: Accessor<TRow, number>;
+    y: Accessor<TRow, number>;
+    length?: Accessor<TRow, number> | number;
+    rotate?: Accessor<TRow, number> | number;
+    shape?: 'arrow' | 'spike' | 'arrow-filled';
+    anchor?: 'start' | 'middle' | 'end';
+    style?: {
+        fill?: string;
+        stroke?: string;
+        strokeWidth?: number;
+    };
+};
+/**
+ * Geodesic-aware lines between point pairs — svelteplot's `Link` (its
+ * `curve: 'auto'` traces a great-circle arc on a geographic projection).
+ * https://svelteplot.dev/examples/link/spherical-link
+ */
+export type GeoLinkMarker<TRow extends Record<string, unknown> = Record<string, unknown>> = {
+    type: 'link';
+    data: TRow[];
+    x1: Accessor<TRow, number>;
+    y1: Accessor<TRow, number>;
+    x2: Accessor<TRow, number>;
+    y2: Accessor<TRow, number>;
+    curve?: 'auto' | 'linear';
+    style?: StrokeStyle;
+};
+/**
+ * Marching-squares contours from a scalar field — svelteplot's `Contour`.
+ * https://svelteplot.dev/examples/contour/weather
+ *
+ * Two input modes: pass `data` (+ `x`/`y`/`value` row accessors) to
+ * spatially interpolate a scatter of samples, or omit `data` and pass
+ * `value` as an `(x, y) => number` sampling function.
+ */
+export type GeoContourMarker<TRow extends Record<string, unknown> = Record<string, unknown>> = {
+    type: 'contour';
+    data?: TRow[];
+    x?: Accessor<TRow, number>;
+    y?: Accessor<TRow, number>;
+    value?: Accessor<TRow, number> | ((x: number, y: number) => number);
+    thresholds?: number | number[];
+    fill?: 'value' | string;
+    stroke?: 'value' | string;
+    blur?: number;
+    interpolate?: 'none' | 'nearest' | 'barycentric' | 'random-walk';
+    style?: {
+        strokeWidth?: number;
+        fillOpacity?: number;
+        strokeOpacity?: number;
+    };
+    /**
+     * Masks the contour to just the base map's landmass (`'land'`) or just
+     * its water (`'ocean'`) — e.g. a temperature contour that should only
+     * shade land, leaving the ocean bare (or the reverse).
+     */
+    clip?: 'land' | 'ocean';
+    /**
+     * Renders behind the base map's own fill/stroke instead of on top of it —
+     * lets a filled contour read as background shading with the base map's
+     * feature borders drawn crisply over it, rather than the contour
+     * obscuring them.
+     */
+    behind?: boolean;
+};
+/**
+ * The in-map hover highlight. `strategy` chooses which candidate point set
+ * drives matching: `'nearest-feature'` (base-map feature centroids —
+ * choropleth-style hover) or `'nearest-point'` (a `dot` marker's own rows).
+ */
+export type GeoHoverMarkerConfig = {
+    type: 'hover';
+    strategy?: 'nearest-feature' | 'nearest-point';
+    showLabels?: boolean;
+    format?: (point: HoverDisplayPoint) => string;
+    dotStyle?: DotStyle;
+    fontStyle?: FontStyle;
+};
+/** Mounts an arbitrary Svelte component as a mark — the geo analog of `CustomComponentMarker` (no `series` concept here). */
+export type GeoCustomComponentMarker = {
+    type: 'component';
+    component: any;
+    props?: Record<string, unknown>;
+    data?: any[];
+};
+/**
+ * Which edge of the plot frame an inset is anchored to, and where along that
+ * edge — a `side-anchor` pair joined by `-`, in either word order (so
+ * `'bottom-right'` and `'right-bottom'` are the same corner). `side` is
+ * `top`/`bottom`/`left`/`right`; `anchor` is the same four plus `middle`
+ * (e.g. `'right-middle'` centers the inset vertically along the right edge).
+ */
+export type GeoInsetLocation = 'top-left' | 'left-top' | 'top-middle' | 'middle-top' | 'top-right' | 'right-top' | 'middle-left' | 'left-middle' | 'middle-middle' | 'middle-right' | 'right-middle' | 'bottom-left' | 'left-bottom' | 'bottom-middle' | 'middle-bottom' | 'bottom-right' | 'right-bottom';
+/**
+ * Named projections an `inset` marker can use for its own independently-fit
+ * mini-map — everything `GeoProjectionName` offers except `'identity'`/
+ * `'reflect-y'`, which have no scale/translate of their own to fit (see
+ * `GeoProjectionConfig.domain`'s doc comment) and so can't auto-fit the way
+ * every inset needs to.
+ */
+export type GeoInsetProjectionName = Exclude<GeoProjectionName, 'identity' | 'reflect-y'>;
+/**
+ * Independent hover tooltip scoped to just one `inset` marker's own rendered
+ * features. Matched by nearest projected centroid within the inset's own
+ * local mini-projection/box — entirely decoupled from the plot's own
+ * top-level `tooltip`, which only ever matches the main map's own features
+ * (an inset draws in its own coordinate space, at its own scale, so the
+ * main map's hover has no way to reach it). No `facetId`/`sync`/`strategy`
+ * here, unlike the top-level `TooltipConfig` — an inset never broadcasts
+ * its hover to other facets and always matches punctually.
+ */
+export type GeoInsetTooltipConfig = {
+    /** Tooltip text for the nearest feature (by centroid) to the cursor, within this inset. */
+    format: (feature: GeoFeature<Record<string, unknown>>) => string;
+    /** Custom tooltip body; replaces `format` when given. */
+    content?: Snippet<[{
+        rows: GeoFeature<Record<string, unknown>>[];
+    }]>;
+};
+/** Projection config for an `inset` marker — like `GeoProjectionConfig`, minus `inset`/`domain` (insets always auto-fit to their own content) and custom factories (which can't guarantee `fitExtent`). */
+export type GeoInsetProjectionConfig = GeoInsetProjectionName | {
+    type?: GeoInsetProjectionName;
+    rotate?: [number, number] | [number, number, number];
+    center?: [number, number];
+    parallels?: [number, number];
+    clip?: boolean | null | number | 'frame';
+};
+/**
+ * A small, independently-projected map panel anchored to a corner/edge of
+ * the plot — for showing a region at a different, more legible scale than
+ * the main map (a disjoint territory, a dense metro area, etc.), the way
+ * national mapping agencies commonly draw insets for exactly this reason.
+ *
+ * What it shows is either a filtered subset of the plot's own `data` (via
+ * `features`, matched the same way `segments` keys are) or a wholly
+ * separate dataset (`data`, which takes precedence over `features` when
+ * both are given) — the inset's own mini-projection is fit to whichever one
+ * applies, independently of the main map's projection/zoom.
+ */
+export type GeoInsetMarker<TProps extends Record<string, unknown> = Record<string, unknown>> = {
+    type: 'inset';
+    location: GeoInsetLocation;
+    /** Feature ids (matching the plot's own `featureId`) to filter from the plot's own `data`. Ignored when `data` is set. */
+    features?: string[];
+    /**
+     * Narrows each `features`-matched feature down to just the geometry parts
+     * that pass this predicate (each polygon of a `MultiPolygon`, each line of
+     * a `MultiLineString`) — same `(part, feature)` signature as
+     * `GeoDataProps.excludeParts`, so the same predicate can be passed to both
+     * to split one feature's geometry between the main map and this inset
+     * without preprocessing the source data. Omitted → every part of each
+     * matched feature renders, as before. Ignored when `data` is set.
+     */
+    featurePartsFilter?: (part: {
+        centroid: [number, number];
+        geometry: GeoJSON.Geometry;
+    }, feature: GeoFeature<TProps> & {
+        __id: string;
+    }) => boolean;
+    /** A separate GeoJSON dataset rendered inside the inset instead of a filtered subset of the plot's own `data`. TopoJSON isn't supported here. */
+    data?: GeoJsonInput<TProps>;
+    /** Projection for just this inset, independently fit to whatever it ends up showing. Defaults to `'mercator'`. */
+    projection?: GeoInsetProjectionConfig;
+    /** Inset box size as a fraction of the plot's own width/height. Defaults to `0.26`/`0.22`. */
+    width?: number;
+    height?: number;
+    /** Gap between the inset box and the plot's own edge, in pixels. Defaults to `8`. */
+    margin?: number;
+    style?: GeoSegmentStyle;
+    /** Independent hover tooltip for just this inset's own rendered features — see `GeoInsetTooltipConfig`. */
+    tooltip?: GeoInsetTooltipConfig;
+};
+export type GeoMarker = GeoGraticuleMarker | GeoSphereMarker | GeoDotMarker | GeoVectorMarker | GeoLinkMarker | GeoContourMarker | GeoHoverMarkerConfig | GeoCustomComponentMarker | GeoInsetMarker;

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

@@ -0,0 +1,11 @@
+/**
+ * Baseline props every marker component receives when mounted by a plot:
+ * `data` for the points/values it draws, plus `series`/`seriesColor` when
+ * mounted per-series via a `CustomComponentMarker`. Marker components extend
+ * this with whatever else they need (e.g. PeakMarker's `mode`, `label`).
+ */
+export interface MarkerProps<TData = Record<string, unknown>> {
+    data?: TData[];
+    series?: string;
+    seriesColor?: string;
+}

package/dist/types/markers/props.js

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

package/dist/types/plots/axis.d.ts

@@ -0,0 +1,55 @@
+export type AxisValue = number | string | Date;
+/**
+ * Author-facing scale overrides for a plot axis. Mirrors svelteplot's
+ * `ScaleOptions` + `XScaleOptions` in full — `type`, `padding`, `domain`,
+ * `nice`, `reverse`, `label`, `tickFormat`, `labelAnchor`, etc.
+ *
+ * Used for both `x` and `y` entries in `ScalesConfig`. X-specific
+ * fields (`labelAnchor`, `tickRotate`) are accepted on `y` too; svelteplot
+ * silently ignores any inapplicable options.
+ *
+ * `TData` is the plot's own row type — it's what {@link AxisScale.sort}
+ * receives, so ordering isn't limited to comparing this axis's own value.
+ */
+export type AxisScale<TData = Record<string, unknown>> = {
+    type?: 'auto' | 'linear' | 'pow' | 'sqrt' | 'log' | 'symlog' | 'time' | 'utc' | 'point' | 'ordinal' | 'sequential' | 'band' | 'categorical' | 'cyclical' | 'threshold' | 'quantile-cont' | 'quantile' | 'quantize' | 'diverging' | 'diverging-log' | 'diverging-pow' | 'diverging-sqrt' | 'diverging-symlog';
+    domain?: (number | string | boolean | Date | null)[];
+    range?: (number | string | boolean | Date | null)[];
+    reverse?: boolean;
+    label?: string | false;
+    labelAnchor?: 'auto' | 'left' | 'center' | 'right' | 'bottom' | 'middle' | 'top';
+    labelOrientation?: 'horizontal' | 'vertical';
+    labelPosition?: 'top' | 'middle';
+    titleFontSize?: number;
+    interval?: string | number;
+    clamp?: boolean;
+    nice?: boolean;
+    zero?: boolean;
+    round?: boolean;
+    percent?: boolean;
+    align?: number;
+    base?: number;
+    constant?: number;
+    sort?: (a: TData, b: TData) => number;
+    grid?: boolean | {
+        stroke?: string;
+        strokeWidth?: number;
+        strokeOpacity?: number;
+        strokeDasharray?: string;
+    };
+    padding?: number;
+    paddingInner?: number;
+    paddingOuter?: number;
+    insetLeft?: number;
+    insetRight?: number;
+    insetTop?: number;
+    insetBottom?: number;
+    ticks?: (number | string | boolean | Date | null)[];
+    tickSpacing?: number;
+    tickSize?: number;
+    tickPadding?: number;
+    tickRotate?: number;
+    tickFormat?: false | Intl.NumberFormatOptions | Intl.DateTimeFormatOptions | ((d: unknown, index: number, ticks: unknown[]) => string | string[]);
+    seriesLayout?: 'overlap' | 'grouped' | 'stacked';
+    seriesPadding?: number;
+};

package/dist/types/plots/axis.js

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

package/dist/types/plots/constants.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Unified positional anchor for value labels across all plot kinds.
+ *
+ * - `'outside'` — beyond the tip of the mark (above a vertical bar, to the
+ *   far end of a horizontal bar or line). This is the only value with no
+ *   direct svelteplot equivalent; the plot computes dx/dy internally.
+ * - `'start'` — at the tip of the mark, just inside (top of a bar, far end
+ *   of a pyramid bar from zero, right of a line's last point).
+ * - `'middle'` — centred on the mark.
+ * - `'end'` — at the baseline/zero end of the mark.
+ */
+export type ValueAnchor = 'outside' | 'start' | 'middle' | 'end';
+export type SymbolType = 'circle' | 'square' | 'triangle' | 'line';
+export type LineStyle = 'solid' | 'dashed' | 'dotted' | 'dashdot';
+export type LineCap = 'butt' | 'round' | 'square';
+export type LineJoin = 'arcs' | 'bevel' | 'miter' | 'miter-clip' | 'round';
+/** `font-weight` keyword accepted by any text styling. */
+export type FontWeight = 'normal' | 'bold';
+/** `font-style` keyword accepted by any text styling. */
+export type FontStyleKeyword = 'normal' | 'italic';
+/**
+ * Horizontal text anchor. `'outside'` is only meaningful where the consuming
+ * mark resolves it per-point from a signed x value (currently `HoverMarker`
+ * only) — it anchors the label away from zero: `'start'` (extending right)
+ * for a positive x, `'end'` (extending left) for negative. Elsewhere it's
+ * treated the same as `'start'`.
+ */
+export type TextAnchor = 'start' | 'middle' | 'end' | 'outside';
+/** Vertical text anchor. */
+export type LineAnchor = 'top' | 'middle' | 'bottom';

package/dist/types/plots/constants.js

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