@sophistry/charts 0.0.0-stage → 0.1.0

package/dist/color-norm.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Colour norms: how a colour-mapped layer turns a value into a place on its
+ * ramp (0..1), and the {@link Scale} its colour bar reads the same mapping
+ * from, so cells and colour bar always agree.
+ */
+import type { DivergingKind, Scale } from "@sophistry/core/geometry";
+import type { Colormap } from "@sophistry/core/themes";
+import type { RampExtent } from "./frame/types.js";
+/**
+ * How a colour layer spreads values over its colormap: `"linear"` even
+ * steps; `"log"` even ratios (zero, negative and non-finite values are not
+ * drawn, and the automatic range is the positive extent); `"symlog"`
+ * logarithmic away from zero, linear through it; `"sqrt"` square-root
+ * steps, lifting small values.
+ *
+ * @see https://sophistry.dev/guides/charts/#color
+ * @category Charts
+ */
+export type RampScaleName = DivergingKind;
+/**
+ * The colour-norm props of the colour-mapped layers (`<Imshow>`,
+ * `<Pcolormesh>`, `<Cells>`/`<Heatmap>`, `<Tripcolor>`, the contours).
+ * `<Hist2D>` and `<HexBin>` take `rampScale` alone.
+ *
+ * @see https://sophistry.dev/guides/charts/#color
+ * @category Charts
+ */
+export interface RampScaleProps {
+    /** How values spread over the colormap; see {@link RampScaleName}. @default "linear" */
+    rampScale?: RampScaleName;
+    /**
+     * A diverging centre: this value takes the colormap's middle, each half
+     * spread on its own, so a diverging colormap's neutral colour sits on "no
+     * change". Without `rampMin`/`rampMax`, the range is symmetric about it
+     * (in ratio under `"log"`).
+     */
+    rampMidpoint?: number;
+}
+/**
+ * A layer's resolved colour norm.
+ *
+ * @internal
+ */
+export interface ColorNorm {
+    /** The values the colormap spans, `[low, high]`, ascending. */
+    domain: readonly [number, number];
+    /** The mapping over `domain`, for the colour bar: its ticks and their places. */
+    scale: Scale;
+    /** A value's place on the ramp: 0 at `domain[0]`, 1 at `domain[1]`, beyond for values past them; `NaN` for values with no place. */
+    unit(value: number): number;
+    /** True for the default linear mapping, which needs no colour-bar scale of its own. */
+    linear: boolean;
+}
+/**
+ * Options for {@link colorNorm}: the layer's norm props and its `rampMin`/`rampMax`.
+ *
+ * @internal
+ */
+export interface RampScaleOptions extends RampScaleProps {
+    rampMin?: number;
+    rampMax?: number;
+    /** Return a norm even for the default linear mapping. */
+    always?: boolean;
+}
+/**
+ * The colour norm a layer colours `values` through.
+ *
+ * @param values - Only their finite (positive, under `"log"`) extent is read.
+ * @returns The norm; without `always`, undefined unless a non-linear `rampScale` or a `rampMidpoint` is given.
+ * @internal
+ */
+export declare function colorNorm(values: Iterable<number>, options: RampScaleOptions & {
+    always: true;
+}): ColorNorm;
+export declare function colorNorm(values: Iterable<number>, options: RampScaleOptions): ColorNorm | undefined;
+/**
+ * Contour levels evenly spaced along a norm (geometric under `"log"`, split
+ * evenly either side of a `rampMidpoint`).
+ *
+ * @param ends - `"between"` for iso-lines strictly inside the domain, `"cover"` for band boundaries including both ends.
+ * @internal
+ */
+export declare function normLevels(norm: ColorNorm, count: number, ends: "between" | "cover"): number[];
+/**
+ * What a layer reports to its frame's colour bar: its norm's domain and
+ * scale when it has a non-linear one, else `domain` (linear).
+ *
+ * @internal
+ */
+export declare function rampOf(norm: ColorNorm | undefined, domain: readonly [number, number], colormap: Colormap): RampExtent;

package/dist/context.d.ts

@@ -0,0 +1,111 @@
+/**
+ * How layers find their chart: the context keys a `chart` provides and the
+ * helper every layer calls ({@link chartLayer}), the imperative form of
+ * a chart, layer and colour scale lookup.
+ *
+ * - {@link chartContext}: the frame snapshot ({@link ChartFrame}). A new
+ *   object whenever the fit, the reveal, the colour scale or a transition
+ *   stage changes; a layer reading it with `ctx.context(chartContext)` reruns
+ *   its `update` exactly then.
+ * - {@link chartLayersContext}: where reports go ({@link ChartLayers}),
+ *   stable for the chart's life.
+ * - `coordsContext` (core): the chart publishes its coordinate system there
+ *   too, so core's graphs and annotations plot inside a chart.
+ * - `tooltipContext`, `dateSinkContext`: the chart's tooltip and date sink.
+ */
+import type { CompositeContext, ContextKey, CoordinateSystem } from "@sophistry/core";
+import type { BandKey } from "@sophistry/core/geometry";
+import type { ChartFrame, ChartLayerExtent, ChartLayers } from "./frame/types.js";
+import type { OrdinalColorScale } from "./math/ordinal.js";
+/**
+ * The enclosing chart's frame, or null outside one (a plain `axes`, or no
+ * coordinate system at all). Read it with `ctx.context(chartContext)` inside
+ * `setup`/`update`; see {@link ChartFrame}.
+ *
+ * @category Extending
+ */
+export declare const chartContext: ContextKey<ChartFrame | null>;
+/**
+ * Where the enclosing chart's layers report their extents, or null outside a
+ * chart. Layers use {@link chartLayer} rather than reading it directly.
+ *
+ * @category Extending
+ */
+export declare const chartLayersContext: ContextKey<ChartLayers | null>;
+/**
+ * A layer's link to its chart. See {@link chartLayer}.
+ *
+ * @category Extending
+ */
+export interface ChartLayer {
+    /**
+     * The chart's current frame, or null outside a chart. Reading it reruns
+     * the layer's `update` when the chart publishes a new frame.
+     */
+    frame(): ChartFrame | null;
+    /**
+     * The coordinate system in scope: the chart's (or an `axes`'), else null.
+     * Reading it reruns `update` when it changes.
+     */
+    coords(): CoordinateSystem | null;
+    /**
+     * Sends the layer's extent to the chart (a no-op outside one). Call from
+     * every `update` with the current report; the chart refits only when it
+     * changed by value. `undefined` withdraws the report.
+     */
+    report(extent: ChartLayerExtent | undefined): void;
+    /** The layer's own `progress`, scaled by the frame's data phase (as given outside a chart). */
+    progress(own: number | undefined): number | undefined;
+    /**
+     * The categorical colour scale `series` maps through: inside a chart the
+     * frame's shared scale (report the categories as `color: { categories }`),
+     * outside one a scale over `categories` cycling the theme's colours.
+     */
+    colorScale(categories: readonly BandKey[]): OrdinalColorScale;
+}
+/**
+ * Wires a layer composite into its chart: reports its extent so the frame
+ * can fit its axes, and scales its reveal by the frame's data phase. Outside
+ * a chart it reports nothing and leaves `progress` untouched, so layers also
+ * work in a plain `axes`. Call once, in `setup`; the report is withdrawn
+ * when the layer is disposed.
+ *
+ * @example
+ * ```ts
+ * import { type CompositeContext, circle, defineComposite, Invalidate } from "@sophistry/core";
+ * import { type ChartLayer, chartLayer } from "@sophistry/charts";
+ *
+ * interface PinsProps {
+ * 	xs: readonly number[];
+ * 	ys: readonly number[];
+ * }
+ *
+ * const layers = new WeakMap<object, ChartLayer>();
+ *
+ * function draw(ctx: CompositeContext<PinsProps>) {
+ * 	const layer = layers.get(ctx.node)!;
+ * 	const { xs, ys } = ctx.props;
+ * 	layer.report({ x: { values: xs }, y: { values: ys, zero: true } });
+ * 	const coords = layer.coords();
+ * 	if (!coords) return [];
+ * 	// Build children in data space through `coords`.
+ * 	return xs.map((x, i) => circle.create({ center: coords.coordsToPoint(x, ys[i]), radius: 0.08 }));
+ * }
+ *
+ * export const pins = defineComposite<PinsProps>({
+ * 	name: "Pins",
+ * 	props: {
+ * 		xs: { default: [], invalidates: Invalidate.UPDATE },
+ * 		ys: { default: [], invalidates: Invalidate.UPDATE },
+ * 	},
+ * 	setup: (ctx) => {
+ * 		layers.set(ctx.node, chartLayer(ctx));
+ * 		return draw(ctx);
+ * 	},
+ * 	update: (_changed, ctx) => draw(ctx),
+ * });
+ * ```
+ *
+ * @category Extending
+ */
+export declare function chartLayer<P>(ctx: CompositeContext<P>): ChartLayer;

package/dist/curves/density.d.ts

@@ -0,0 +1,125 @@
+/**
+ * `density`: a kernel density estimate per `series`, drawn as one path
+ * batch (per curve a closed fill item, then its open line) in a group whose
+ * clip the `"x"` reveal sweeps. With `row`, curves stand in a band axis's
+ * rows: a ridgeline.
+ */
+import type { ColorInput } from "@sophistry/core/color";
+import type { BandKey } from "@sophistry/core/geometry";
+import type { Channel } from "../data/channels.js";
+import type { DensityReveal, SeriesTransitionProps } from "../props.js";
+/**
+ * Props of {@link density}: `x` defaults to the datum when `data` is
+ * `number[]`; name it otherwise.
+ *
+ * @category Charts
+ */
+export interface DensityProps<T = unknown> extends SeriesTransitionProps<T> {
+    /** The sample: one value per datum. */
+    data: readonly T[];
+    /**
+     * The sample value, in data units. Defaults to the datum when `data` is `number[]`; required
+     * otherwise. Non-finite values are dropped.
+     */
+    x?: Channel<T, number>;
+    /** Gaussian kernel bandwidth, in data units. Defaults to Silverman's rule of thumb. */
+    bandwidth?: number;
+    /**
+     * How many points the curve is evaluated at.
+     * @default 80
+     */
+    samples?: number;
+    /** The x span to evaluate over. Defaults to the data's extent padded by three bandwidths. */
+    domain?: [number, number];
+    /**
+     * The category of each datum: one curve per category (each with area 1), coloured through the
+     * chart's shared colour scale and legend. `color` wins.
+     */
+    series?: Channel<T, BandKey>;
+    /**
+     * With a `series`: scale each curve by its share of the data, so all areas add up to 1.
+     * @default false
+     */
+    commonNorm?: boolean;
+    /**
+     * `"vertical"`: values along x, density up y. `"horizontal"`: values up y, density to the right
+     * (a marginal beside a y axis).
+     * @default "vertical"
+     */
+    orientation?: "vertical" | "horizontal";
+    /**
+     * Sit the curve in a category's band on a band axis instead of on a density axis: a ridgeline,
+     * one `density` per row. `true` with a `series` puts each category on its own row.
+     */
+    row?: BandKey | true;
+    /**
+     * With `row`: the peak height, in band slots (above 1 overlaps the next row).
+     * @default 1.4
+     */
+    rowHeight?: number;
+    /**
+     * With `row`: what reaches `rowHeight`: `"own"` each curve's own peak, `"shared"` the tallest
+     * among this layer's curves, or a density shared across several layers.
+     * @default "own"
+     */
+    rowScale?: "own" | "shared" | number;
+    /**
+     * Curve and fill colour. Defaults to the `series` colour, else the theme's first series colour.
+     */
+    color?: ColorInput;
+    /**
+     * Fill opacity under the curve, 0..1 (0 for the curve alone).
+     * @default 0.3
+     */
+    fillOpacity?: number;
+    /** Width of the curve. */
+    strokeWidth?: number;
+    /** Opacity 0..1. @default 1 */
+    opacity?: number;
+    /**
+     * Reveal, 0..1: `reveal="x"` sweeps the curve in along the values; `"grow"` raises it from its
+     * baseline.
+     * @default 1
+     * @see https://sophistry.dev/guides/chart-animation/#reveals
+     */
+    progress?: number;
+    /** How `progress` reveals. @default "x" */
+    reveal?: DensityReveal;
+    /**
+     * The sample to transition to, curves matched by `series`: shared curves morph in place, new
+     * ones sweep (or grow) in, leaving ones fade out. See {@link SeriesTransitionProps}.
+     * @see https://sophistry.dev/guides/chart-animation/#data-transitions
+     */
+    to?: readonly T[];
+    /** Paint order (both curve and fill paint under the axes of that order). */
+    zIndex?: number;
+    /** Set to false to hide the curves. */
+    visible?: boolean;
+}
+/**
+ * A kernel density estimate of a sample, drawn as an area whose y axis reads
+ * probability density. With `row`, curves sit in a band axis's rows: a
+ * ridgeline. Inside a `chart` or `axes`. See `gaussianKde` for the estimate
+ * alone.
+ *
+ * @example
+ * ```ts
+ * import { chart, density } from "@sophistry/charts";
+ *
+ * const rows = [
+ * 	{ group: "a", height: 162 },
+ * 	{ group: "a", height: 171 },
+ * 	{ group: "b", height: 175 },
+ * 	{ group: "b", height: 183 },
+ * ];
+ * chart.create({
+ * 	width: 8,
+ * 	height: 4,
+ * 	children: [density.create({ data: rows, x: "height", series: "group", row: true })],
+ * });
+ * ```
+ *
+ * @see https://sophistry.dev/reference/chart-catalogue/#distributions
+ * @category Charts
+ */
+export declare const density: import("@sophistry/core").Definition<DensityProps<any>, import("@sophistry/core/internal").CompositeNode<DensityProps<any>>, keyof DensityProps<any>>;

package/dist/curves/ecdf.d.ts

@@ -0,0 +1,72 @@
+/**
+ * `ecdf`: an empirical cumulative distribution function per `series`, drawn
+ * as `stairs` draws its lines (one path batch, see {@link drawStepLines}).
+ */
+import type { BandKey } from "@sophistry/core/geometry";
+import type { Channel } from "../data/channels.js";
+import type { CurveReveal, SeriesTransitionProps } from "../props.js";
+import type { StepLineStyleProps } from "./stairs.js";
+/**
+ * Props of {@link ecdf}: `value` defaults to the datum when `data` is
+ * `number[]`; name it otherwise.
+ *
+ * @category Charts
+ */
+export interface EcdfProps<T = unknown> extends SeriesTransitionProps<T>, StepLineStyleProps {
+    /** One observation per datum. */
+    data: readonly T[];
+    /**
+     * The observed value, in data units. Defaults to the datum when `data` is `number[]`; required
+     * otherwise. Non-finite values are dropped.
+     */
+    value?: Channel<T, number>;
+    /**
+     * Data-space padding left of the smallest and right of the largest value; see {@link
+     * ecdfSteps}. Defaults to 5% of the span (0.5 when all values are equal).
+     */
+    pad?: number;
+    /**
+     * How `progress` reveals the curve: along x or by arc length.
+     * @default "x"
+     * @see https://sophistry.dev/guides/chart-animation/#reveals
+     */
+    reveal?: CurveReveal;
+    /**
+     * The category of each datum: one curve per category, coloured through the chart's shared
+     * colour scale and legend. `stroke` wins.
+     */
+    series?: Channel<T, BandKey>;
+    /**
+     * The sample to transition to, curves matched by `series`: shared curves morph and stay step
+     * functions, new ones sweep in, leaving ones fade out. See {@link SeriesTransitionProps}.
+     * @see https://sophistry.dev/guides/chart-animation/#data-transitions
+     */
+    to?: readonly T[];
+}
+/**
+ * An empirical cumulative distribution function: a step function rising
+ * from 0 to 1, jumping at each observed value. One curve per `series`.
+ * Inside a `chart` or an `axes` with a y range like `[0, 1, 0.25]`. See
+ * {@link ecdfSteps} for the steps alone.
+ *
+ * @example
+ * ```ts
+ * import { chart, ecdf } from "@sophistry/charts";
+ *
+ * const samples = [
+ * 	{ group: "a", height: 162 },
+ * 	{ group: "a", height: 171 },
+ * 	{ group: "b", height: 175 },
+ * 	{ group: "b", height: 183 },
+ * ];
+ * chart.create({
+ * 	width: 8,
+ * 	height: 4,
+ * 	children: [ecdf.create({ data: samples, value: "height", series: "group" })],
+ * });
+ * ```
+ *
+ * @see https://sophistry.dev/reference/chart-catalogue/#distributions
+ * @category Charts
+ */
+export declare const ecdf: import("@sophistry/core").Definition<EcdfProps<any>, import("@sophistry/core/internal").CompositeNode<EcdfProps<any>>, keyof EcdfProps<any>>;

package/dist/curves/fill-between.d.ts

@@ -0,0 +1,100 @@
+/**
+ * `fillBetween`: the shaded region between two channels (or one and the
+ * baseline), one region per `series`, drawn as one path batch (a closed
+ * item per region) in a group whose clip the `"x"` reveal sweeps;
+ * `reveal="length"` traces each region's outline instead (the item's
+ * `progress`), its fill coming up with it.
+ */
+import type { PaintSpec } from "@sophistry/core";
+import type { BandKey, CurveKind } from "@sophistry/core/geometry";
+import type { Channel, PositionValue } from "../data/channels.js";
+import type { CurveReveal, SeriesTransitionProps } from "../props.js";
+/**
+ * Props of {@link fillBetween}: `x` and `y1` default to the index and the
+ * datum when `data` is `number[]`; name them otherwise.
+ *
+ * @category Charts
+ */
+export interface FillBetweenProps<T = unknown> extends SeriesTransitionProps<T> {
+    /** One sample per datum along x; the region splits wherever `x`, `y1` or `y2` is non-finite. */
+    data: readonly T[];
+    /**
+     * X position, in data units (a `Date` reads as epoch ms). Defaults to the index when `data` is
+     * `number[]`; required otherwise.
+     */
+    x?: Channel<T, PositionValue>;
+    /**
+     * One boundary, in data units. Defaults to the datum when `data` is `number[]`; required
+     * otherwise.
+     */
+    y1?: Channel<T, number>;
+    /** The other boundary, in data units. Defaults to a flat line at the axis baseline. */
+    y2?: Channel<T, number>;
+    /**
+     * How `progress` reveals the region: `"x"` fills it left to right behind a straight front;
+     * `"length"` traces its outline and fades the fill up.
+     * @default "x"
+     * @see https://sophistry.dev/guides/chart-animation/#reveals
+     */
+    reveal?: CurveReveal;
+    /**
+     * How both boundaries run between points: `"linear"` or any {@link CurveKind}. A `linePlot`
+     * with the same `curve` traces the region's edge.
+     * @default "linear"
+     */
+    curve?: CurveKind;
+    /**
+     * The category of each datum: one region per category (a band per group), filled through the
+     * chart's shared colour scale and legend. `fill` wins.
+     */
+    series?: Channel<T, BandKey>;
+    /**
+     * The data to transition to, regions matched by `series`: shared regions morph (both bounds
+     * blended per x), new ones sweep in, leaving ones fade out. See {@link SeriesTransitionProps}.
+     * @see https://sophistry.dev/guides/chart-animation/#data-transitions
+     */
+    to?: readonly T[];
+    /** Region fill for every region. Defaults to the `series` colour, else the theme's first series colour. */
+    fill?: string;
+    /** Fill opacity 0..1. @default 0.3 */
+    fillOpacity?: number;
+    /** Region outline. @default "none" */
+    stroke?: PaintSpec;
+    /** Outline width. */
+    strokeWidth?: number;
+    /** Opacity 0..1. @default 1 */
+    opacity?: number;
+    /** Reveal 0..1 (see `reveal`). @default 1 */
+    progress?: number;
+    /** Paint order (the fill paints under the axes of that order). */
+    zIndex?: number;
+    /** Set to false to hide the regions. */
+    visible?: boolean;
+}
+/**
+ * The shaded region between two channels of the same data, or between one
+ * and the baseline when `y2` is omitted: a translucent band behind a
+ * {@link linePlot}. Gaps in the data split it. Inside a `chart` or `axes`.
+ * For a function, use `areaUnderGraph`. See {@link fillBetweenRings} for the
+ * geometry alone.
+ *
+ * @example
+ * ```ts
+ * import { chart, fillBetween } from "@sophistry/charts";
+ *
+ * const rows = [
+ * 	{ t: 0, low: 1, high: 3 },
+ * 	{ t: 1, low: 2, high: 5 },
+ * 	{ t: 2, low: 1.5, high: 4 },
+ * ];
+ * chart.create({
+ * 	width: 8,
+ * 	height: 4,
+ * 	children: [fillBetween.create({ data: rows, x: "t", y1: "high", y2: "low" })],
+ * });
+ * ```
+ *
+ * @see https://sophistry.dev/reference/chart-catalogue/#lines-scatter-and-error-bars
+ * @category Charts
+ */
+export declare const fillBetween: import("@sophistry/core").Definition<FillBetweenProps<any>, import("@sophistry/core/internal").CompositeNode<FillBetweenProps<any>>, keyof FillBetweenProps<any>>;

package/dist/curves/index.d.ts

@@ -0,0 +1,15 @@
+/** Family barrel: lines and areas. Re-exported from the package entry. */
+export type { DensityProps } from "./density.js";
+export { density } from "./density.js";
+export type { EcdfProps } from "./ecdf.js";
+export { ecdf } from "./ecdf.js";
+export type { FillBetweenProps } from "./fill-between.js";
+export { fillBetween } from "./fill-between.js";
+export type { LinePlotProps } from "./line-plot.js";
+export { linePlot } from "./line-plot.js";
+export type { RegressionProps } from "./regression.js";
+export { regressionPlot } from "./regression.js";
+export type { StackPlotProps } from "./stack-plot.js";
+export { stackPlot } from "./stack-plot.js";
+export type { StairsProps, StepLineStyleProps } from "./stairs.js";
+export { stairs } from "./stairs.js";

package/dist/curves/line-plot.d.ts

@@ -0,0 +1,104 @@
+/**
+ * `linePlot`: a line through data points, one per `series`, drawn as one
+ * path batch (an open outline per line, each with its own stroke and fade).
+ *
+ * A keyed transition (`to` + `blend`) matches lines by `series`: shared lines
+ * morph on one x grid (`morphRuns`), entering ones sweep in along x, leaving
+ * ones fade. `progress` cuts every line at one front along x (the cut
+ * geometry is drawn whole), or with `reveal="length"` draws each line along
+ * its arc length (the item's `progress`).
+ * A line far longer than the plot is wide is decimated to the plot's
+ * columns at rest.
+ */
+import type { PaintSpec } from "@sophistry/core";
+import type { BandKey, CurveKind } from "@sophistry/core/geometry";
+import type { Channel, PositionValue } from "../data/channels.js";
+import type { CurveReveal, SeriesTransitionProps } from "../props.js";
+/**
+ * Props of {@link linePlot}: `x` and `y` default to the index and the datum
+ * when `data` is `number[]`; name them otherwise.
+ *
+ * @category Charts
+ */
+export interface LinePlotProps<T = unknown> extends SeriesTransitionProps<T> {
+    /** One point per datum, in order; a datum with a non-finite `x` or `y` lifts the pen. */
+    data: readonly T[];
+    /**
+     * X position, in data units (a `Date` reads as epoch ms). Defaults to the index when `data` is
+     * `number[]`; required otherwise.
+     */
+    x?: Channel<T, PositionValue>;
+    /**
+     * Y position, in data units (a `Date` reads as epoch ms). Defaults to the datum when `data` is
+     * `number[]`; required otherwise.
+     */
+    y?: Channel<T, PositionValue>;
+    /**
+     * How `progress` reveals the line: `"x"` sweeps it in left to right at a constant rate along x;
+     * `"length"` draws it by arc length (better for a connected scatter).
+     * @default "x"
+     * @see https://sophistry.dev/guides/chart-animation/#reveals
+     */
+    reveal?: CurveReveal;
+    /**
+     * How the line runs between points: `"linear"`, `"monotone"` (smooth, never overshoots),
+     * `"natural"`, `"catmull-rom"`, or `"step"`/`"step-before"`/`"step-after"`. See {@link
+     * CurveKind}.
+     * @default "linear"
+     */
+    curve?: CurveKind;
+    /**
+     * The category of each datum: one line per category, coloured through the chart's shared colour
+     * scale and legend. `stroke` wins.
+     */
+    series?: Channel<T, BandKey>;
+    /**
+     * The data to transition to, lines matched by `series`: shared lines morph (y blended per x),
+     * new ones sweep in, leaving ones fade out. See {@link SeriesTransitionProps}.
+     * @see https://sophistry.dev/guides/chart-animation/#data-transitions
+     */
+    to?: readonly T[];
+    /** Line colour (or gradient) for every line. Defaults to the `series` colour, else the theme's foreground. */
+    stroke?: PaintSpec;
+    /** Line width. Defaults to the theme's stroke width. */
+    strokeWidth?: number;
+    /** Dash pattern, in scene units. Solid when omitted. */
+    dash?: number[];
+    /** Offset into `dash`. @default 0 */
+    dashOffset?: number;
+    /** How line ends are capped. @default "round" */
+    lineCap?: CanvasLineCap;
+    /** How corners are joined. @default "round" */
+    lineJoin?: CanvasLineJoin;
+    /** Opacity 0..1. @default 1 */
+    opacity?: number;
+    /** Reveal 0..1 (see `reveal`). @default 1 */
+    progress?: number;
+    /** Paint order. */
+    zIndex?: number;
+    /** Set to false to hide the lines. */
+    visible?: boolean;
+}
+/**
+ * A line through data points, in data coordinates; one line per `series`.
+ * Non-finite points split the line into runs. Inside a `chart` (or any
+ * `axes`). For a function `y = f(x)`, use `functionGraph`. Drawn as one path
+ * batch: one item per line.
+ *
+ * @example
+ * ```ts
+ * import { chart, linePlot } from "@sophistry/charts";
+ *
+ * // number[] data: x is the index, y the value. With records, name the
+ * // channels: linePlot.create({ data: rows, x: "year", y: (d) => d.sales / 1000 }).
+ * chart.create({
+ * 	width: 8,
+ * 	height: 5,
+ * 	children: [linePlot.create({ data: [1, 4, 3, 7, 6, 9] })],
+ * });
+ * ```
+ *
+ * @see https://sophistry.dev/reference/chart-catalogue/#lines-scatter-and-error-bars
+ * @category Charts
+ */
+export declare const linePlot: import("@sophistry/core").Definition<LinePlotProps<any>, import("@sophistry/core/internal").CompositeNode<LinePlotProps<any>>, keyof LinePlotProps<any>>;