@fundar/data-chart-telling 0.0.64 → 1.0.0

package/dist/types/layout/statistics/box.d.ts

@@ -0,0 +1,8 @@
+import type { BoxMarkerConfig } from '../../markers/common';
+/**
+ * Options for `type: 'box'` - the box plot's own styling and tick options,
+ * same fields and defaults as a `box` marker (see `BoxMarkerConfig`'s own
+ * doc comment). Summarizes the source's own distribution, one box per
+ * category.
+ */
+export type BoxStatisticOptions = Omit<BoxMarkerConfig, 'type' | 'data' | 'x' | 'y' | 'series'>;

package/dist/types/layout/statistics/box.js

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

package/dist/types/layout/statistics/density.d.ts

@@ -0,0 +1,27 @@
+import type { AreaStyle } from '../../plots/styling';
+import type { DensityKernel } from '../../transforms/density';
+export type { DensityKernel } from '../../transforms/density';
+/**
+ * Options for `type: 'density'` - a 1D kernel density estimate over the
+ * `x` values, drawn as a filled area. Runs the `densityX` transform (same
+ * option names); the curve's own `y` is the density. To run the estimate on a
+ * marker of your own, or on a plot's own rows, use that transform directly.
+ */
+export type DensityStatisticOptions = {
+    kernel?: DensityKernel;
+    /** Kernel bandwidth in data units; Silverman's rule picks one from the data when unset. */
+    bandwidth?: number;
+    styles?: AreaStyle;
+};
+/**
+ * Options for `type: 'density2d'` - 2D contour bands, same options as the
+ * `density` marker (svelteplot's own `Density` mark). Set `thresholds` to
+ * control the number of bands or give the density levels explicitly.
+ */
+export type Density2DStatisticOptions = {
+    /** Gaussian kernel bandwidth in pixels - svelteplot defaults to 20. */
+    bandwidth?: number;
+    /** Contour level count, or an explicit list of density thresholds. */
+    thresholds?: number | number[];
+    styles?: AreaStyle;
+};

package/dist/types/layout/statistics/density.js

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

package/dist/types/layout/statistics/index.d.ts

@@ -0,0 +1,46 @@
+import type { RegressionStatisticOptions } from './regression';
+import type { BollingerStatisticOptions } from './bollinger';
+import type { MovingAverageStatisticOptions } from './movingAverage';
+import type { DensityStatisticOptions, Density2DStatisticOptions } from './density';
+import type { BoxStatisticOptions } from './box';
+export type { RegressionType, RegressionStatisticOptions } from './regression';
+export type { BollingerStatisticOptions } from './bollinger';
+export type { StatisticReducer, MovingAverageStatisticOptions } from './movingAverage';
+export type { DensityKernel, DensityStatisticOptions, Density2DStatisticOptions } from './density';
+export type { BoxStatisticOptions } from './box';
+/**
+ * Which series a plot-level statistic runs over. Omitted: one derived
+ * statistic per series, so a plot grouped by `color`/`grouping` gets its
+ * statistics grouped the same way. Named: only the listed series. `pooled:
+ * true`: one statistic over every series combined. Ignored on a marker's own
+ * `.statistics` - a marker has exactly one source, its own `data`.
+ */
+export type StatisticScope = {
+    series?: string[];
+    pooled?: boolean;
+};
+/**
+ * A statistic to compute and draw as one or more derived markers - the same
+ * shape whether attached to a plot's own top-level `statistics` prop or a
+ * marker's own `.statistics`. `regression`/`bollinger` resolve straight to
+ * svelteplot's own `RegressionX`/`Y` and `BollingerX`/`Y` marks (no
+ * computation of our own); `movingAverage` has no svelteplot mark, so it
+ * calls svelteplot's own `windowY` transform and wraps the result into a
+ * `line` marker. `density` (1D) calls svelteplot's own `densityX` transform
+ * and wraps the curve into an `area` marker; `density2d` and `box` resolve
+ * straight to the same `density` and `box` markers a plot author can write
+ * directly.
+ */
+export type StatisticConfig = StatisticScope & (({
+    type: 'regression';
+} & RegressionStatisticOptions) | ({
+    type: 'bollinger';
+} & BollingerStatisticOptions) | ({
+    type: 'movingAverage';
+} & MovingAverageStatisticOptions) | ({
+    type: 'density';
+} & DensityStatisticOptions) | ({
+    type: 'density2d';
+} & Density2DStatisticOptions) | ({
+    type: 'box';
+} & BoxStatisticOptions));

package/dist/types/layout/statistics/index.js

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

package/dist/types/layout/statistics/movingAverage.d.ts

@@ -0,0 +1,12 @@
+import type { StrokeStyle } from '../../plots/styling';
+import type { WindowReducer } from '../../transforms/window';
+/** Window reducers the `windowY` transform takes by name. */
+export type StatisticReducer = WindowReducer;
+/** Sliding-window options for `type: 'movingAverage'` - runs the `windowY` transform. */
+export type MovingAverageStatisticOptions = {
+    /** Window size, in number of points. */
+    k: number;
+    /** Reducer applied within each window. Defaults to `'mean'`. */
+    reduce?: StatisticReducer;
+    styles?: StrokeStyle;
+};

package/dist/types/layout/statistics/movingAverage.js

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

package/dist/types/layout/statistics/regression.d.ts

@@ -0,0 +1,20 @@
+import type { StrokeStyle } from '../../plots/styling';
+/**
+ * Regression model svelteplot's own `RegressionX`/`RegressionY` marks support
+ * - same names, so nothing new to learn if you already know svelteplot.
+ */
+export type RegressionType = 'linear' | 'quad' | 'poly' | 'exp' | 'log' | 'pow' | 'loess';
+/** Fit options for `type: 'regression'` - mirrors svelteplot's own `RegressionOptions` field-for-field. */
+export type RegressionStatisticOptions = {
+    regressionType?: RegressionType;
+    /** Polynomial order (`regressionType: 'poly'`). */
+    order?: number;
+    /** Logarithm base (`regressionType: 'log'`). */
+    base?: number;
+    /** LOESS bandwidth, as a fraction of the data range, 0-1 (`regressionType: 'loess'`). */
+    span?: number;
+    /** Confidence-band level (e.g. `0.95`); svelteplot's own default is `0.99`. Set `false` to omit the band. */
+    confidence?: number | false;
+    /** The band always renders in the same color as `stroke`, at a fixed low opacity - no separate band color to set. */
+    styles?: StrokeStyle;
+};

package/dist/types/layout/statistics/regression.js

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

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

@@ -3,37 +3,31 @@ import type { FontStyle, StrokeStyle, AreaStyle } from '../plots/styling';
 import type { GeoFeature } from '../plots/data/geo';
 import type { GapsConfig } from '../plots/gaps';
 /**
- * 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.
+ * Controls if and how value labels are rendered on a plot, drawn as a `text`
+ * marker over the rows the plot itself draws (after its own `transforms`):
+ * one at the end of each series on a line or area plot, one per bar on a bar,
+ * pyramid or histogram plot, one per point on a scatter plot and one per cell
+ * on a heatmap. 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 = {
+    /** Whether the labels are drawn. Off by default, except on a heatmap. */
     show?: boolean;
+    /** Where each label sits on its mark - see {@link ValueAnchor}. */
     anchor?: ValueAnchor;
+    /** A label's text, from its row's own value (a histogram bin's count) and its series. */
     format?: (value: number, seriesName: string) => string;
+    /** Hovering a label dims every other series, like toggling them off in the legend. */
     hoverIsolate?: boolean;
     fontStyle?: FontStyle;
+    /** The connectors a line or area plot routes back from labels that had to move apart. */
     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
+ * 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
@@ -46,16 +40,14 @@ export type FrameStyle = AreaStyle & {
     insetBottom?: number;
     insetLeft?: number;
 };
-/** Author-facing `styles.frame` prop — see {@link FrameStyle}. */
+/** Author-facing `styles.frame` prop - see {@link FrameStyle}. */
 export type FrameProp = boolean | FrameStyle;
 /**
- * The fields every plot kind's own `styles` shape shares, regardless of
- * whether it's built on axes ({@link AxisBasedStylesConfig}) or geometry
- * ({@link GeoStylesConfig}) — the true common parent of the two, unlike the
- * name `AxisBasedStylesConfig` might suggest before this split existed.
+ * The fields every plot kind's own `styles` shape shares - the common parent
+ * of {@link AxisBasedStylesConfig} and {@link GeoStylesConfig}.
  */
 export type BasePlotStylesConfig = {
-    /** Decorative border around the plot's content box — see {@link FrameStyle}. Available on every plot kind. */
+    /** Decorative border around the plot's content box - see {@link FrameStyle}. Available on every plot kind. */
     frame?: FrameProp;
 };
 /**
@@ -65,13 +57,12 @@ export type BasePlotStylesConfig = {
  */
 export type AxisBasedStylesConfig = BasePlotStylesConfig & {
     values?: ValuesStyle;
-    colors?: ColorsStyle;
 };
 /**
- * `AxisBasedStylesConfig` extended with `gaps` — the interpolated
+ * `AxisBasedStylesConfig` extended with `gaps` - the interpolated
  * missing-data bridge fill available to plot kinds with an inherent
  * category/sequence ordering (`LinePlot`, `BarPlot`, `PyramidPlot`).
- * Resolved per series like `segments`, at zone granularity — see
+ * Resolved per series like `segments`, at zone granularity - see
  * {@link GapsConfig}.
  */
 export type GapsAwarePlotStylesConfig<TSegmentStyle extends object> = AxisBasedStylesConfig & {
@@ -88,7 +79,7 @@ export type GeoTileLayerConfig = {
     tileSize?: number;
 };
 /**
- * `styles` prop for GeoPlot — the geo analog of `AxisBasedStylesConfig`,
+ * `styles` prop for GeoPlot - the geo analog of `AxisBasedStylesConfig`,
  * sharing only {@link BasePlotStylesConfig}'s common ground with it. 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
@@ -100,15 +91,13 @@ export type GeoStylesConfig<TProps extends Record<string, unknown> = Record<stri
     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;
 };
 /**
- * `GeoTileLayerConfig`, plus `features` — never author-facing (the public
+ * `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
@@ -120,7 +109,7 @@ type GeoTileLayerConfigWithFeatures = GeoTileLayerConfig & {
     }[];
 };
 /**
- * The minimal slice of a plot kind's own `styles` prop `StylesLayout` reads —
+ * The minimal slice of a plot kind's own `styles` prop `StylesLayout` reads -
  * every concrete `styles` type ({@link AxisBasedStylesConfig},
  * {@link GeoStylesConfig}) structurally satisfies this whether or not it
  * declares `tileLayer` at all (a missing optional field type-checks fine).

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

@@ -1,7 +1,7 @@
 import type { Snippet } from 'svelte';
-import type { AxisValue } from './scales';
+import type { AxisValue } from './mapping';
 import type { Accessor } from '../plots/data/common';
-import type { EasingName, EasingFn } from '../charts/interpolate';
+import type { EasingName, EasingFn } from '../misc/easing';
 export type TimeValue = number;
 export type Orientation = 'horizontal' | 'vertical';
 export type TimelineChildContext<TRow extends Record<string, unknown>> = {
@@ -20,13 +20,60 @@ export type TimelineInterpolation<TRow extends Record<string, unknown>> = {
     progressEasing?: EasingName | EasingFn;
     segmentEasing?: EasingName | EasingFn;
 };
-export type TimelineConfig<TRow extends Record<string, unknown>> = {
+/** How a timeline draws: a `'player'` bar in the chrome (the default), or a `'rule'` beside the plot. */
+export type TimelineType = 'rule' | 'player';
+/** A piece of the player bar. */
+export type PlayerControl = 'play' | 'value' | 'slider' | 'speed' | 'loop';
+/**
+ * The player bar (`timeline.type: 'player'`): which controls it draws, in what
+ * order, and how it plays. `loop` and `speed` are where the player starts: it
+ * keeps them from there, and tells `onloop` and `onspeed` when they change.
+ */
+export type PlayerConfig = {
+    /** The controls drawn, in this order - one left out isn't drawn. Defaults to the configuration's `timeline.player.controls`. */
+    controls?: PlayerControl[];
+    /** Starts playing as soon as the timeline has steps. */
+    autoplay?: boolean;
+    /** Starts again from the first step after the last, instead of stopping. */
+    loop?: boolean;
+    /** The playing speed, as a multiple of `stepDuration`. Defaults to `1`. */
+    speed?: number;
+    /** The speeds the speed control cycles through. Defaults to the configuration's `timeline.player.speeds`. */
+    speeds?: number[];
+    /** Milliseconds each step lasts at speed `1`. Defaults to the configuration's `timeline.player.stepDuration`. */
+    stepDuration?: number;
+    /** How the current step reads in the `'value'` control. Defaults to the step itself. */
+    format?: (value: TimeValue) => string;
+    onplay?: (playing: boolean) => void;
+    onspeed?: (speed: number) => void;
+    onloop?: (loop: boolean) => void;
+};
+/** What every timeline can tell its owner, whatever it draws as. */
+export type TimelineCallbacks = {
+    /** Called with the new position, `0`-`1`, whenever the player or the reader moves it. */
+    onprogress?: (progress: number) => void;
+    /** Called with the step the position lands on, when that step changes. */
+    onvalue?: (value: TimeValue) => void;
+};
+export type TimelineConfig<TRow extends Record<string, unknown>> = TimelineCallbacks & {
     accessor: Accessor<TRow, TimeValue>;
-    progress: number;
+    /** How it draws. Defaults to `'player'`. */
+    type?: TimelineType;
+    /** The player bar's own options, when `type` is `'player'`. */
+    player?: PlayerConfig;
+    /**
+     * The timeline's position, `0`-`1`. A `'player'` keeps its own position from
+     * there on (see `onprogress`), until this changes. Inside a `PlotComposer`
+     * with its own `timeline`, the composer's wins and nothing draws here.
+     */
+    progress?: number;
     values?: TimeValue[];
+    /** Which way a `'rule'` runs. A `'player'` is always horizontal. */
     orientation?: Orientation;
     show?: boolean;
     thickness?: number;
     filterMode?: 'exact' | 'upTo';
     interpolate?: boolean | TimelineInterpolation<TRow>;
+    /** `'shared'` (default): x and y span every step's rows, so the axes hold still while scrubbing; `'free'` refits them to each step. */
+    scales?: 'shared' | 'free';
 };

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

@@ -1,36 +1,17 @@
 import type { Snippet } from 'svelte';
-import type { AxisValue } from './scales';
+import type { HoverStrategy } from './hover';
 /**
- * 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).
- * - `'punctual'` exact XY match — one cell at a time (default for heatmap).
- * - `'series'` all points sharing the hovered series, regardless of x/y.
- */
-export type HoverStrategy = 'x' | 'y' | 'punctual' | 'series';
-/**
- * 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'`.
+ * Preferred horizontal placement of the tooltip beside the cursor; it moves
+ * to the other side when it would overflow. Defaults to `'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'`.
- */
+/** Preferred vertical placement of the tooltip, like {@link TooltipAnchorX}. Defaults to `'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. */
     strategy?: HoverStrategy;
-    /**
-     * Broadcast the hover to other facets. When `true` every facet with a
-     * matching point highlights it using the same strategy. Defaults to `false`.
-     */
+    /** Highlight the hovered point in every synced plot too. Defaults to `false`. */
     sync?: boolean;
     /** Custom tooltip text for a row (supports `\n`). Defaults per chart kind. */
     format?: (row: TRow) => string;
@@ -40,69 +21,10 @@ export type TooltipOptions<TRow extends Record<string, unknown>> = {
     content?: Snippet<[{
         rows: TRow[];
     }]>;
-    /** Preferred horizontal anchor — see {@link TooltipAnchorX}. */
+    /** Preferred horizontal anchor - see {@link TooltipAnchorX}. */
     anchorX?: TooltipAnchorX;
-    /** Preferred vertical anchor — see {@link TooltipAnchorY}. */
+    /** 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>;
-/**
- * Shared hover state for cross-facet tooltip syncing.
- *
- * {@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.
- */
-export type HoverStore = {
-    activeX: AxisValue | null;
-    activeY: AxisValue | null;
-    /** Series of the hovered row, when the plot kind has a series concept (line/bar). */
-    activeSeries: string | null;
-    /**
-     * Mouse position within the source facet's own box, as a fraction of its
-     * width/height (each in `[0, 1]`). Other facets reproject this onto their
-     * own box so a broadcast tooltip lands at the same *relative* spot the
-     * cursor is actually at, rather than a fixed corner.
-     */
-    cursorFrac: {
-        x: number;
-        y: number;
-    } | null;
-    /** Facet id that currently owns the hover (`''` when not faceted). */
-    source: string | null;
-    /** How related points are found within a facet. */
-    strategy: HoverStrategy;
-    /** Whether the hover is broadcast to other facets. */
-    sync: boolean;
-};
-/** A point ready to render: its plotted position plus its label. */
-export type HoverDisplayPoint = {
-    x: AxisValue;
-    y: AxisValue;
-    label: string;
-    /** Owning series name; undefined for plot kinds with no series concept (heatmap). */
-    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 'grouped' series' own slice of the category band, as start/end fractions (0–1) of the whole band. `undefined` means the whole band. */
-    areaInset?: {
-        start: number;
-        end: number;
-    };
-};
-/** A candidate point for hover matching/highlighting — also carries its source row. */
-export type HoverPoint<T> = HoverDisplayPoint & {
-    row: T;
-};

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

@@ -1,11 +1,10 @@
 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
+ * 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
+ * used as any `Plot.svelte`'s own `TMarker` - see each kind's own precise
  * type instead.
  */
-export type MarkerConfig = AxisBasedMarkersConfig | LineMarkersConfig | GeoMarkersConfig | GeoFeaturesMarkerConfig;
+export type MarkerConfig = AxisBasedMarkersConfig | GeoMarkersConfig | GeoFeaturesMarkerConfig;

package/dist/types/markers/axis/area.d.ts

@@ -0,0 +1,12 @@
+import type { AreaStyle } from '../../plots/styling';
+import type { CommonMarkerConfigWithArea } from '../channels/commonMarkerConfigWithArea';
+import type { CommonMarkerConfigWithColor } from '../channels/commonMarkerConfigWithColor';
+import type { CommonMarkerConfigWithInterval } from '../channels/commonMarkerConfigWithInterval';
+import type { MarkerCurveName } from './curveName';
+/** A filled area under a curve, or a band between two curves (svelteplot's `AreaX`/`AreaY`). */
+export type AreaMarkerConfig = {
+    type: 'area';
+    curve?: MarkerCurveName;
+    tension?: number;
+    styles?: AreaStyle;
+} & CommonMarkerConfigWithArea & CommonMarkerConfigWithColor & CommonMarkerConfigWithInterval;

package/dist/types/markers/axis/area.js

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

package/dist/types/markers/axis/arrow.d.ts

@@ -0,0 +1,15 @@
+import type { StrokeStyle } from '../../plots/styling';
+import type { CommonMarkerConfigWithInterval } from '../channels/commonMarkerConfigWithInterval';
+/** A point-to-point arrow (svelteplot's `Arrow`), from `x1`/`y1` to `x2`/`y2`. */
+export type ArrowMarkerConfig = {
+    type: 'arrow';
+    /** Bend angle in degrees; `true` is shorthand for 22.5. */
+    bend?: number | true;
+    headAngle?: number;
+    headLength?: number;
+    inset?: number;
+    insetStart?: number;
+    insetEnd?: number;
+    sweep?: 1 | 0 | -1 | '+x' | '-x' | '+y' | '-y';
+    styles?: StrokeStyle;
+} & CommonMarkerConfigWithInterval;

package/dist/types/markers/axis/arrow.js

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

package/dist/types/markers/axis/axisBasedMarkersConfig.d.ts

@@ -0,0 +1,29 @@
+import type { BasicMarkersConfig } from '../basic/basicMarkersConfig';
+import type { LineMarkerConfig } from './line';
+import type { BarMarkerConfig } from './bar';
+import type { CellMarkerConfig } from './cell';
+import type { RectMarkerConfig } from './rect';
+import type { RegressionMarkerConfig } from './regression';
+import type { BollingerMarkerConfig } from './bollinger';
+import type { AreaMarkerConfig } from './area';
+import type { DensityMarkerConfig } from './density';
+import type { BoxMarkerConfig } from './box';
+import type { HullMarkerConfig } from './hull';
+import type { DifferenceMarkerConfig } from './difference';
+import type { ArrowMarkerConfig } from './arrow';
+import type { BrushMarkerConfig } from './brush';
+import type { DelaunayLinkMarkerConfig } from './delaunayLink';
+import type { DelaunayMeshMarkerConfig } from './delaunayMesh';
+import type { VoronoiMarkerConfig } from './voronoi';
+import type { VoronoiMeshMarkerConfig } from './voronoiMesh';
+import type { ImageMarkerConfig } from './image';
+import type { RasterMarkerConfig } from './raster';
+import type { TickMarkerConfig } from './tick';
+import type { TrailMarkerConfig } from './trail';
+import type { WaffleMarkerConfig } from './waffle';
+import type { RuleMarkerConfig } from './rule';
+import type { HoverMarkerConfig } from './hover';
+import type { CustomComponentMarkerConfig } from './component';
+import type { DeltaMarkerConfig } from './delta';
+/** Every marker kind an axis-based plot can render. */
+export type AxisBasedMarkersConfig = BasicMarkersConfig | LineMarkerConfig | BarMarkerConfig | CellMarkerConfig | RectMarkerConfig | RegressionMarkerConfig | BollingerMarkerConfig | AreaMarkerConfig | DensityMarkerConfig | BoxMarkerConfig | HullMarkerConfig | DifferenceMarkerConfig | ArrowMarkerConfig | BrushMarkerConfig | DelaunayLinkMarkerConfig | DelaunayMeshMarkerConfig | VoronoiMarkerConfig | VoronoiMeshMarkerConfig | ImageMarkerConfig | RasterMarkerConfig | TickMarkerConfig | TrailMarkerConfig | WaffleMarkerConfig | RuleMarkerConfig | HoverMarkerConfig | CustomComponentMarkerConfig | DeltaMarkerConfig;

package/dist/types/markers/axis/axisBasedMarkersConfig.js

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

package/dist/types/markers/axis/bar.d.ts

@@ -0,0 +1,18 @@
+import type { AxisValue } from '../../layout/mapping';
+import type { AreaStyle } from '../../plots/styling';
+import type { CommonMarkerConfigWithColor } from '../channels/commonMarkerConfigWithColor';
+import type { CommonMarkerConfigWithInterval } from '../channels/commonMarkerConfigWithInterval';
+/** A bar mark; `role` tells a visible segment from the hover hit area and highlight. */
+export type BarMarkerConfig = {
+    type: 'bar';
+    role: 'segment' | 'hitArea' | 'highlight';
+    isHorizontal: boolean;
+    insetTop?: number;
+    insetBottom?: number;
+    insetLeft?: number;
+    insetRight?: number;
+    styles?: AreaStyle;
+    category?: AxisValue;
+    /** A `'hitArea'` that matches `data` as the plot's hover while the pointer is over it. */
+    hover?: boolean;
+} & CommonMarkerConfigWithColor & CommonMarkerConfigWithInterval;

package/dist/types/markers/axis/bar.js

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

package/dist/types/markers/axis/bollinger.d.ts

@@ -0,0 +1,6 @@
+import type { BollingerStatisticOptions } from '../../layout/statistics';
+import type { CommonMarkerConfig } from '../channels/commonMarkerConfig';
+/** A moving-average band (svelteplot's `BollingerX`/`BollingerY`). */
+export type BollingerMarkerConfig = {
+    type: 'bollinger';
+} & BollingerStatisticOptions & CommonMarkerConfig;

package/dist/types/markers/axis/bollinger.js

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

package/dist/types/markers/axis/box.d.ts

@@ -0,0 +1,14 @@
+import type { CommonMarkerConfig } from '../channels/commonMarkerConfig';
+/**
+ * A box plot (svelteplot's `BoxX`/`BoxY`). Styled per sub-mark through `bar`,
+ * `rule`, `dot`, `tickMedian` and `tickMinMax`, each forwarded to svelteplot.
+ */
+export type BoxMarkerConfig = {
+    type: 'box';
+    sort?: 'min' | 'max' | 'median' | 'p25' | 'p75' | '-min' | '-max' | '-median' | '-p25' | '-p75';
+    bar?: Record<string, unknown>;
+    rule?: Record<string, unknown>;
+    dot?: Record<string, unknown>;
+    tickMedian?: boolean | Record<string, unknown>;
+    tickMinMax?: boolean | Record<string, unknown>;
+} & CommonMarkerConfig;

package/dist/types/markers/axis/box.js

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

package/dist/types/markers/axis/brush.d.ts

@@ -0,0 +1,28 @@
+import type { StrokeStyle } from '../../plots/styling';
+import type { CommonMarkerConfig } from '../channels/commonMarkerConfig';
+/** Live selection rectangle of a brush marker, the same shape as svelteplot's `Brush` state. */
+export type BrushSelection = {
+    x1?: number | Date;
+    x2?: number | Date;
+    y1?: number | Date;
+    y2?: number | Date;
+    enabled: boolean;
+};
+/** An interactive drag-to-select rectangle (svelteplot's `Brush`), drawn in screen space. */
+export type BrushMarkerConfig = {
+    type: 'brush';
+    brush?: BrushSelection;
+    limitDimension?: false | 'x' | 'y';
+    constrainToDomain?: boolean;
+    resizeHandleSize?: number;
+    onbrushstart?: (event: MouseEvent & {
+        brush: BrushSelection;
+    }) => void;
+    onbrush?: (event: MouseEvent & {
+        brush: BrushSelection;
+    }) => void;
+    onbrushend?: (event: MouseEvent & {
+        brush: BrushSelection;
+    }) => void;
+    styles?: StrokeStyle;
+} & Pick<CommonMarkerConfig, 'series'>;

package/dist/types/markers/axis/brush.js

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

package/dist/types/markers/axis/cell.d.ts

@@ -0,0 +1,9 @@
+import type { AreaStyle } from '../../plots/styling';
+import type { CommonMarkerConfigWithArea } from '../channels/commonMarkerConfigWithArea';
+import type { CommonMarkerConfigWithColor } from '../channels/commonMarkerConfigWithColor';
+/** A heatmap cell mark; `fill` is always set per row. */
+export type CellMarkerConfig = {
+    type: 'cell';
+    styles?: AreaStyle;
+    inset?: number;
+} & CommonMarkerConfigWithColor & Required<Pick<CommonMarkerConfigWithArea, 'fill'>>;

package/dist/types/markers/axis/cell.js

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