@sophistry/charts 0.0.0-stage → 0.0.1

package/dist/points/rects.d.ts

@@ -0,0 +1,81 @@
+/**
+ * `rects`: rectangles in data space from `x1`/`x2`/`y1`/`y2`; a pair left
+ * out spans the plot that way. One `rect` instances node per layer.
+ *
+ * Each rectangle reveals by tracing its outline while its
+ * fill comes up (the item's `progress` channel: its reveal and presence).
+ */
+import type { ColorInput } from "@sophistry/core/color";
+import type { MarkTransition } from "../batch";
+import type { Channel, ColorChannel, PositionValue } from "../data/channels";
+import type { KeyedTransitionProps, RevealProps } from "../props";
+import type { TooltipSpec } from "../tooltip";
+/**
+ * Props of {@link rects}.
+ *
+ * @category Charts
+ */
+export interface RectsProps<T = unknown> extends KeyedTransitionProps<T>, RevealProps {
+    /** One rectangle per datum. */
+    data: readonly T[];
+    /** Left edge, in data units (a `Date` reads as epoch ms). With `x2` also omitted, the rectangle spans the plot's full width. */
+    x1?: Channel<T, PositionValue>;
+    /** Right edge, in data units. */
+    x2?: Channel<T, PositionValue>;
+    /** Bottom edge, in data units. With `y2` also omitted, the rectangle spans the plot's full height. */
+    y1?: Channel<T, PositionValue>;
+    /** Top edge, in data units. */
+    y2?: Channel<T, PositionValue>;
+    /** Fill, constant or `(d, i) => colour`. Wins over `colors`. */
+    color?: ColorChannel<T>;
+    /** Colours cycled across the rectangles by index. Defaults to the theme's categorical colours. */
+    colors?: readonly ColorInput[];
+    /**
+     * Fill opacity, 0..1.
+     * @default 0.35
+     */
+    fillOpacity?: number;
+    /**
+     * Outline colour.
+     * @default "none"
+     */
+    stroke?: ColorInput;
+    strokeWidth?: number;
+    opacity?: number;
+    /**
+     * Reveal, 0..1: each rectangle traces its outline as its fill comes up.
+     * @default 1
+     */
+    progress?: number;
+    /** Hover tooltip: `(d, i) => string`. */
+    tooltip?: TooltipSpec<T>;
+    /** How rectangles move when `data` changes outside a `to` blend; see {@link MarkTransition}. */
+    transition?: MarkTransition;
+    /**
+     * Paint order; higher draws later. Behind the data by default.
+     * @default -1
+     */
+    zIndex?: number;
+    visible?: boolean;
+}
+/**
+ * Rectangles in data space from `x1`/`x2`/`y1`/`y2`. Leave out a pair and the rectangle spans
+ * the plot that way: a vertical or horizontal span (shaded recessions, a target band); with all
+ * four, a floating box. Drawn behind the data by default. One instances node.
+ *
+ * @example
+ * ```ts
+ * import { chart, rects } from "@sophistry/charts";
+ *
+ * const recessions = [
+ * 	{ start: 2001.2, end: 2001.9 },
+ * 	{ start: 2008, end: 2009.5 },
+ * ];
+ * chart.create({ width: 8, height: 4, children: [rects.create({ data: recessions, x1: "start", x2: "end" })] });
+ * ```
+ *
+ * @see https://sophistry.dev/guides/charts/#marks
+ * @category Charts
+ */
+export declare const rects: import("@sophistry/core").Definition<RectsProps<any>, import("@sophistry/core/internal").CompositeNode<RectsProps<any>>, keyof RectsProps<any>>;
+//# sourceMappingURL=rects.d.ts.map

package/dist/points/rects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rects.d.ts","sourceRoot":"","sources":["../../src/points/rects.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AASH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAExD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAI/C,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAgB7E,OAAO,KAAK,EAAY,oBAAoB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5E,OAAO,KAAK,EAAE,WAAW,EAAgB,MAAM,YAAY,CAAC;AAO5D;;;;GAIG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC,GAAG,OAAO,CACtC,SAAQ,oBAAoB,CAAC,CAAC,CAAC,EAC9B,WAAW;IACZ,+BAA+B;IAC/B,IAAI,EAAE,SAAS,CAAC,EAAE,CAAC;IACnB,gIAAgI;IAChI,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC;IAC/B,iCAAiC;IACjC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC;IAC/B,sGAAsG;IACtG,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC;IAC/B,+BAA+B;IAC/B,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC;IAC/B,gEAAgE;IAChE,KAAK,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;IACxB,kGAAkG;IAClG,MAAM,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;IAC/B;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,yCAAyC;IACzC,OAAO,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IACzB,gGAAgG;IAChG,UAAU,CAAC,EAAE,cAAc,CAAC;IAC5B;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAyOD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,KAAK,iJA8EhB,CAAC"}

package/dist/points/rug.d.ts

@@ -0,0 +1,73 @@
+/**
+ * `rug`: a short tick standing on the axis at every value, drawn as one
+ * `line` instances node (see `segment-marks.ts`).
+ */
+import type { BandKey } from "@sophistry/core/geometry";
+import type { MarkTransition } from "../batch";
+import type { Channel, ColorChannel } from "../data/channels";
+import type { KeyedTransitionProps, RevealProps } from "../props";
+import type { TooltipSpec } from "../tooltip";
+/**
+ * Props of {@link rug}.
+ *
+ * @category Charts
+ */
+export interface RugProps<T = unknown> extends KeyedTransitionProps<T>, RevealProps {
+    /** One tick per datum. */
+    data: readonly T[];
+    /** The value, in data units. Defaults to the datum when `data` is `number[]`. */
+    value?: Channel<T, number>;
+    /**
+     * Which axis the rug lines.
+     * @default "x"
+     */
+    axis?: "x" | "y";
+    /**
+     * Tick length.
+     * @default 0.18
+     */
+    length?: number;
+    /**
+     * The series each tick belongs to: colours ticks through the chart's shared colour scale and
+     * legend, so a rug matches its per-series densities. `color` wins.
+     */
+    series?: Channel<T, BandKey>;
+    /** Tick colour, constant or `(d, i) => colour`. Defaults to the `series` colour, else the theme's first series colour. */
+    color?: ColorChannel<T>;
+    /** Line width. */
+    strokeWidth?: number;
+    /**
+     * Opacity, so overlapping ticks read darker.
+     * @default 0.7
+     */
+    opacity?: number;
+    /**
+     * Reveal, 0..1: each tick draws out of the axis.
+     * @default 1
+     */
+    progress?: number;
+    /** Hover tooltip: `true` for the value and `series`, or a template, function or options. */
+    tooltip?: TooltipSpec<T>;
+    /** How ticks move when `data` changes outside a `to` blend; see {@link MarkTransition}. */
+    transition?: MarkTransition;
+    zIndex?: number;
+    visible?: boolean;
+}
+/**
+ * A rug: a short tick standing on the axis at every value, the raw sample
+ * under a density or histogram. For ticks centred on the axis or spanning a
+ * band, use `tickX` / `tickY`. Drawn as one instances node; ticks point
+ * into the plot, and `progress` draws each out of the axis.
+ *
+ * @example
+ * ```ts
+ * import { chart, rug } from "@sophistry/charts";
+ *
+ * chart.create({ width: 8, height: 4, children: [rug.create({ data: [1, 2, 2.5, 4] })] });
+ * ```
+ *
+ * @see https://sophistry.dev/reference/chart-catalogue/#distributions
+ * @category Charts
+ */
+export declare const rug: import("@sophistry/core").Definition<RugProps<any>, import("@sophistry/core/internal").CompositeNode<RugProps<any>>, keyof RugProps<any>>;
+//# sourceMappingURL=rug.d.ts.map

package/dist/points/rug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rug.d.ts","sourceRoot":"","sources":["../../src/points/rug.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,OAAO,EAAiB,MAAM,0BAA0B,CAAC;AACvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAG/C,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAiB9D,OAAO,KAAK,EAAY,oBAAoB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAG5E,OAAO,KAAK,EAAE,WAAW,EAAgB,MAAM,YAAY,CAAC;AAU5D;;;;GAIG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC,GAAG,OAAO,CACpC,SAAQ,oBAAoB,CAAC,CAAC,CAAC,EAC9B,WAAW;IACZ,0BAA0B;IAC1B,IAAI,EAAE,SAAS,CAAC,EAAE,CAAC;IACnB,iFAAiF;IACjF,KAAK,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;IAC3B;;;OAGG;IACH,IAAI,CAAC,EAAE,GAAG,GAAG,GAAG,CAAC;IACjB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IAC7B,0HAA0H;IAC1H,KAAK,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;IACxB,kBAAkB;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4FAA4F;IAC5F,OAAO,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IACzB,2FAA2F;IAC3F,UAAU,CAAC,EAAE,cAAc,CAAC;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAqQD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,GAAG,2IAkDd,CAAC"}

package/dist/points/scatter.d.ts

@@ -0,0 +1,170 @@
+/**
+ * `scatter`: a marker per datum, drawn as one instances node.
+ *
+ * The reference per-datum mark of the charts package: every other one
+ * (strip, rug, ticks, stem, error bars, ...) follows the same steps in its
+ * `update`:
+ *
+ * 1. read the chart (`layer.frame()`, `layer.coords()`) and the channels
+ *    (with the chart's date sink);
+ * 2. join `data` and `to` by key (`createKeyedData`) and take each key's
+ *    frame at this `blend` (`joinFrames`);
+ * 3. report the extent (both ends while a transition runs);
+ * 4. build one item per key (scene-unit position, size, colour, reveal) at
+ *    this frame of the reveal and transition;
+ * 5. hand the items to the batched node (`createBatchedMark`), with the
+ *    mark's `transition` only for data changes outside a `to` blend.
+ *
+ * Work is split: everything read from the data and the
+ * join (each key's marker in data units) is cached on its inputs, so a pan
+ * or zoom (only the coordinates changing) re-projects and nothing else, and
+ * a frame of a reveal only recomputes each marker's reveal.
+ *
+ * Markers are instances of the internal `symbolMarker` shape: all circles
+ * publish `circle` marks (the splat path); other symbols, constant or per
+ * datum, share the node (see `symbol-marker.ts`). The reveal is each
+ * marker's own `progress` channel (its outline traced), so a partly revealed layer is drawn from outlines and is
+ * discs again once whole. The items are the drawn markers themselves: the
+ * channels read their centres from one projected array, so a pan builds no
+ * per-marker objects beyond the points the node keeps. With `time` + `trail`, the
+ * trails are one path batch behind the markers.
+ */
+import type { BandKey } from "@sophistry/core/geometry";
+import type { MarkTransition } from "../batch";
+import type { Channel, ChannelFn, ColorChannel, PositionValue, Quantity } from "../data/channels";
+import type { SymbolName } from "../math/symbol";
+import type { KeyedTransitionProps, RevealProps, StaggerOrder } from "../props";
+import type { TooltipSpec } from "../tooltip";
+/**
+ * Options for {@link scatter}'s `trail`.
+ *
+ * @category Charts
+ */
+export interface ScatterTrailOptions {
+    /** How much time the trail spans, in the `time` channel's units. Defaults to all of it. */
+    length?: number;
+    /**
+     * The trail's opacity, 0..1.
+     * @default 0.45
+     */
+    opacity?: number;
+    /**
+     * The trail's width.
+     * @default 0.035
+     */
+    strokeWidth?: number;
+}
+/**
+ * Props of {@link scatter}.
+ *
+ * @category Charts
+ */
+export interface ScatterProps<T = unknown> extends KeyedTransitionProps<T>, RevealProps {
+    /** One marker per datum; data with a non-finite `x` or `y` are skipped. */
+    data: readonly T[];
+    /** X position, in data units (a `Date` reads as epoch ms). Defaults to the index when `data` is `number[]`. */
+    x?: Channel<T, PositionValue>;
+    /** Y position, in data units. Defaults to the datum when `data` is `number[]`. */
+    y?: Channel<T, PositionValue>;
+    /**
+     * Marker radius in scene units, constant or per marker. To size markers by a data value, use
+     * `size`.
+     * @default 0.09
+     */
+    radius?: Quantity<T>;
+    /**
+     * Size by value (a bubble chart): radius by a square-root scale from zero, so a marker's area
+     * is proportional to its value. Wins over `radius`. Inside a `chart`, sized layers share one
+     * scale unless `scales: { size: "independent" }`.
+     */
+    size?: Channel<T, number>;
+    /**
+     * With `size`: the radii a value of 0 and a value of `sizeMaxValue` get.
+     * @default [0, 0.35]
+     */
+    sizeRange?: readonly [min: number, max: number];
+    /**
+     * With `size`: the value that reaches `sizeRange[1]`. Pin it to compare sizes across charts or
+     * across a transition. Defaults to the greatest `size` in the chart's sized layers.
+     */
+    sizeMaxValue?: number;
+    /** The category of each marker: colours markers through the chart's shared colour scale and legend. `color` wins. */
+    series?: Channel<T, BandKey>;
+    /** Marker fill, constant or `(d, i) => colour`. Defaults to the `series` colour, else the theme's first series colour. */
+    color?: ColorChannel<T>;
+    /**
+     * Marker shape, constant or per marker: `"circle"`, `"square"`, `"diamond"`, `"triangle"`,
+     * `"cross"` or `"star"`, each with the area of a circle of the same `radius`.
+     * @default "circle"
+     */
+    symbol?: SymbolName | ChannelFn<T, SymbolName>;
+    /** The order `stagger` (and `enterStagger`) reveals markers in. @default "position" */
+    staggerOrder?: StaggerOrder;
+    /** Hover tooltip: `true` for a row per channel (`x`, `y`, `series`, `size`), or a template, function or options. */
+    tooltip?: TooltipSpec<T>;
+    /**
+     * Time as an encoding (a Gapminder chart): each datum is one moment of the thing its `key` (or
+     * `series`) names, and one marker per key is drawn at the moment `at`, interpolated between
+     * keyframes. The axes fit every moment. `to` is ignored.
+     */
+    time?: Channel<T, number>;
+    /** With `time`: the moment to draw. Defaults to the last moment in the data. */
+    at?: number;
+    /**
+     * With `time`: how long a key takes to grow in before its first moment and shrink away after
+     * its last, in `time` units. 0 shows it only between them. Defaults to half the shortest step
+     * between moments.
+     */
+    timeFade?: number;
+    /** With `time`: draw the path each marker has travelled up to `at`, behind the markers. */
+    trail?: boolean | ScatterTrailOptions;
+    /**
+     * How markers move when `data` changes (outside a `to` blend): a tween
+     * or a spring in the node's tween bank; new markers grow in, removed ones
+     * shrink away. Omitted, data changes are instant.
+     */
+    transition?: MarkTransition;
+    /** Marker outline. @default "none" */
+    stroke?: string;
+    /** Outline width. */
+    strokeWidth?: number;
+    /** Opacity 0..1. @default 1 */
+    opacity?: number;
+    /** Fill opacity 0..1, on top of `opacity`. @default 1 */
+    fillOpacity?: number;
+    /** Reveal 0..1: each marker traces its outline, its fill coming up with it (staggered with `stagger`). @default 1 */
+    progress?: number;
+    /** Paint order. */
+    zIndex?: number;
+    /** Set to false to hide the markers. */
+    visible?: boolean;
+}
+/**
+ * A scatter plot or bubble chart: one marker per datum at `(x, y)`, sized
+ * and coloured by value or constant. Drawn as one instances node: hover and
+ * tooltips resolve per marker (`event.key` is the datum's key), the layer is
+ * one tab stop whose markers the arrow keys walk, and `transition` tweens or
+ * springs markers to new data. `to` + `blend` is the seekable keyed
+ * transition; `time` + `at` plays the data back through time.
+ *
+ * @example
+ * ```ts
+ * import { chart, scatter } from "@sophistry/charts";
+ *
+ * const cities = [
+ * 	{ gdp: 15, life: 76, population: 10, continent: "South America" },
+ * 	{ gdp: 80, life: 83, population: 1, continent: "Europe" },
+ * 	{ gdp: 12, life: 71, population: 20, continent: "Asia" },
+ * ];
+ * chart.create({
+ * 	width: 8,
+ * 	height: 4,
+ * 	children: [scatter.create({ data: cities, x: "gdp", y: "life", size: "population", series: "continent", tooltip: true })],
+ * });
+ * ```
+ *
+ * @see https://sophistry.dev/reference/chart-catalogue/#lines-scatter-and-error-bars
+ * @category Charts
+ */
+export declare const scatter: import("@sophistry/core").Definition<ScatterProps<any>, import("@sophistry/core/internal").CompositeNode<ScatterProps<any>>, keyof ScatterProps<any>>;
+//# sourceMappingURL=scatter.d.ts.map

package/dist/points/scatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scatter.d.ts","sourceRoot":"","sources":["../../src/points/scatter.ts"],"names":[],"mappings":"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"}

package/dist/points/segment-marks.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Straight lines in a batched layer, shared by the per-datum marks whose
+ * data are short segments (a rug's ticks, a stem's drop lines, `tickX` /
+ * `tickY`, an event raster, links). Internal.
+ *
+ * A layer of segments is one `instances(line, ...)` node: every
+ * item is a real stroke (caps, any space), each its own outline in the
+ * node's `paths` spec, with `from` / `to` / `stroke` per item.
+ *
+ * A segment's reveal is its item's `progress` channel: the stroke traces
+ * from `from` towards `to`.
+ */
+import type { LineProps, SceneNode } from "@sophistry/core";
+import type { Point } from "@sophistry/core/geometry";
+import type { BatchedMark, BatchItem } from "../batch";
+/** One segment of a batched layer: its two ends in scene units and its colour. */
+export interface SegmentItem extends BatchItem {
+    /** Where it starts (the end a reveal draws from), in scene units. */
+    from: Point;
+    /** Where it ends. */
+    to: Point;
+    /** Its stroke colour. */
+    stroke: string;
+    /** How far it has traced from `from`, 0..1. @default 1 */
+    progress?: number;
+    /** Its opacity (the layer's folded in), when the layer was made with `opacity: true`. */
+    opacity?: number;
+}
+/** The batched node of a segment layer. */
+export type SegmentMark<S extends SegmentItem> = BatchedMark<S, LineProps, SceneNode<LineProps>, keyof LineProps>;
+/**
+ * Makes the one `line` instances node of a segment layer (see `options`). Under a mark's
+ * `transition`, an entering segment draws out of its start and a leaving
+ * one draws back into it (its `progress`). Call once, in `setup`.
+ */
+export declare function createSegmentMark<S extends SegmentItem>(options?: {
+    /** Read each item's `opacity` (a fade per segment) instead of a shared one. */
+    opacity?: boolean;
+}): SegmentMark<S>;
+//# sourceMappingURL=segment-marks.d.ts.map

package/dist/points/segment-marks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment-marks.d.ts","sourceRoot":"","sources":["../../src/points/segment-marks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAGvD,kFAAkF;AAClF,MAAM,WAAW,WAAY,SAAQ,SAAS;IAC7C,qEAAqE;IACrE,IAAI,EAAE,KAAK,CAAC;IACZ,qBAAqB;IACrB,EAAE,EAAE,KAAK,CAAC;IACV,yBAAyB;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,yFAAyF;IACzF,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,2CAA2C;AAC3C,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,WAAW,IAAI,WAAW,CAC3D,CAAC,EACD,SAAS,EACT,SAAS,CAAC,SAAS,CAAC,EACpB,MAAM,SAAS,CACf,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,WAAW,EACtD,OAAO,GAAE;IACR,+EAA+E;IAC/E,OAAO,CAAC,EAAE,OAAO,CAAC;CACb,GACJ,WAAW,CAAC,CAAC,CAAC,CAehB"}

package/dist/points/shared.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Plumbing the point marks share: stable tooltip handlers for a batched
+ * layer, and a last-value cache for the shared props handed to it. Internal.
+ */
+import type { Point } from "@sophistry/core/geometry";
+import type { TooltipContent, TooltipState } from "../tooltip";
+/** The interaction props of a batched layer with tooltips. */
+export interface ItemHandlerProps {
+    label?: string;
+    onEnter?: (event: never) => void;
+    onLeave?: (event: never) => void;
+    onTap?: (event: never) => void;
+    itemLabel?: (item: number) => string | undefined;
+}
+/**
+ * A batched layer's tooltip handlers, made once so their identities hold
+ * across updates (the layer's shared props then compare equal and the node
+ * restyles nothing). Call once, in `setup`.
+ *
+ * @param tooltip - The chart's tooltip state, or null outside a chart.
+ * @param textOf - Item `event.item`'s tooltip, or undefined for none.
+ * @param atOf - Where item `event.item`'s tooltip points, in scene units.
+ * @returns `(enabled, label)`: the props to spread into the layer's shared
+ *   props, empty when `enabled` is false or there is no tooltip.
+ */
+export declare function createItemHandlers(tooltip: TooltipState | null, textOf: (item: number) => TooltipContent | undefined, atOf: (item: number) => Point | undefined): (enabled: boolean, label: string) => ItemHandlerProps;
+/** Whether a mark with this `tooltip` prop shows tooltips in this chart. */
+export declare function tooltipsOn(tooltip: TooltipState | null, own: unknown): boolean;
+/**
+ * A last-value cache for a batched layer's shared props: hands back the
+ * previous object while the next one is shallowly equal, so the node sees
+ * no change.
+ */
+export declare function stableShared<P extends object>(): (next: P) => P;
+//# sourceMappingURL=shared.d.ts.map

package/dist/points/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/points/shared.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAEtD,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/D,8DAA8D;AAC9D,MAAM,WAAW,gBAAgB;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAC/B,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CACjD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CACjC,OAAO,EAAE,YAAY,GAAG,IAAI,EAC5B,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,cAAc,GAAG,SAAS,EACpD,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,KAAK,GAAG,SAAS,GACvC,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,KAAK,gBAAgB,CAUvD;AAED,4EAA4E;AAC5E,wBAAgB,UAAU,CACzB,OAAO,EAAE,YAAY,GAAG,IAAI,EAC5B,GAAG,EAAE,OAAO,GACV,OAAO,CAKT;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,KAAK,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAO/D"}

package/dist/points/stem.d.ts

@@ -0,0 +1,76 @@
+/**
+ * `stem`: a drop line from the baseline to each value, capped with a
+ * marker. Two instances nodes per layer: the drop lines (`line`, see
+ * `segment-marks.ts`) and the markers (`circle`), registered in that order
+ * so every marker paints over every line.
+ *
+ * A gradient `stroke` keeps one `line` and one `circle` node per stem: a gradient paints in its own shape's frame, which a batched
+ * item does not have (the core rejects gradient fills on instances).
+ */
+import type { CircleProps } from "@sophistry/core";
+import type { BandKey } from "@sophistry/core/geometry";
+import type { MarkTransition } from "../batch";
+import type { Channel, ColorChannel, PositionValue } from "../data/channels";
+import type { KeyedTransitionProps, RevealProps, StaggerOrder } from "../props";
+/**
+ * Props of {@link stem}.
+ *
+ * @category Charts
+ */
+export interface StemProps<T = unknown> extends KeyedTransitionProps<T>, RevealProps {
+    /** One drop line and marker per datum; data with a non-finite `x` or `y` are skipped. */
+    data: readonly T[];
+    /** X position, in data units (a `Date` reads as epoch ms). Defaults to the index when `data` is `number[]`. */
+    x?: Channel<T, PositionValue>;
+    /** Y position, in data units. Defaults to the datum when `data` is `number[]`. */
+    y?: Channel<T, number>;
+    /** Data-space y the drop lines start from. Defaults to the axis baseline. */
+    baseline?: number;
+    /** The series each stem belongs to: colours stems through the chart's shared colour scale and legend. `color` and `stroke` win. */
+    series?: Channel<T, BandKey>;
+    /**
+     * Colour of the drop line and marker, constant or `(d, i) => colour`. Defaults to `stroke`,
+     * else the `series` colour, else the theme's first series colour.
+     */
+    color?: ColorChannel<T>;
+    /** Line paint, a colour or a gradient; `color` wins. */
+    stroke?: CircleProps["stroke"];
+    /** Line width. */
+    strokeWidth?: number;
+    opacity?: number;
+    /**
+     * Marker radius.
+     * @default 0.09
+     */
+    markerRadius?: number;
+    /** The order `stagger` and `enterStagger` take. @default "position" */
+    staggerOrder?: StaggerOrder;
+    /**
+     * Reveal, 0..1: each line grows from the baseline, the marker riding its tip (fading in
+     * instead when the axis has no zero).
+     * @default 1
+     */
+    progress?: number;
+    /** How stems move when `data` changes outside a `to` blend; see {@link MarkTransition}. */
+    transition?: MarkTransition;
+    zIndex?: number;
+    visible?: boolean;
+}
+/**
+ * A stem plot: a drop line from the baseline to each value, capped with a
+ * marker. `progress` grows each line from the baseline, the marker riding
+ * its tip (fading in instead when the axis has no zero). Two instances
+ * nodes: lines, then markers.
+ *
+ * @example
+ * ```ts
+ * import { chart, stem } from "@sophistry/charts";
+ *
+ * chart.create({ width: 8, height: 4, children: [stem.create({ data: [3, 1, 4, 1, 5] })] });
+ * ```
+ *
+ * @see https://sophistry.dev/reference/chart-catalogue/#lines-scatter-and-error-bars
+ * @category Charts
+ */
+export declare const stem: import("@sophistry/core").Definition<StemProps<any>, import("@sophistry/core/internal").CompositeNode<StemProps<any>>, keyof StemProps<any>>;
+//# sourceMappingURL=stem.d.ts.map

package/dist/points/stem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stem.d.ts","sourceRoot":"","sources":["../../src/points/stem.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,WAAW,EAA+B,MAAM,iBAAiB,CAAC;AAQhF,OAAO,KAAK,EAAE,OAAO,EAAS,MAAM,0BAA0B,CAAC;AAE/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAI/C,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAiB7E,OAAO,KAAK,EAEX,oBAAoB,EACpB,WAAW,EACX,YAAY,EACZ,MAAM,UAAU,CAAC;AAUlB;;;;GAIG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC,GAAG,OAAO,CACrC,SAAQ,oBAAoB,CAAC,CAAC,CAAC,EAC9B,WAAW;IACZ,yFAAyF;IACzF,IAAI,EAAE,SAAS,CAAC,EAAE,CAAC;IACnB,+GAA+G;IAC/G,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC;IAC9B,kFAAkF;IAClF,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;IACvB,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mIAAmI;IACnI,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IAC7B;;;OAGG;IACH,KAAK,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;IACxB,wDAAwD;IACxD,MAAM,CAAC,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC;IAC/B,kBAAkB;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,uEAAuE;IACvE,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2FAA2F;IAC3F,UAAU,CAAC,EAAE,cAAc,CAAC;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAwSD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,IAAI,8IAyDf,CAAC"}

package/dist/points/strip.d.ts

@@ -0,0 +1,146 @@
+/**
+ * `strip` and `beeswarm`: one dot per value, spread across its category's
+ * band (by seeded jitter, or packed without overlap). One `circle`
+ * instances node per layer.
+ */
+import type { BandKey } from "@sophistry/core/geometry";
+import type { MarkTransition } from "../batch";
+import type { Channel, ColorChannel } from "../data/channels";
+import type { KeyedTransitionProps, RevealProps, StaggerOrder } from "../props";
+import type { TooltipSpec } from "../tooltip";
+/**
+ * What {@link strip} and {@link beeswarm} share.
+ *
+ * @category Charts
+ */
+export interface DotDistributionProps<T> extends KeyedTransitionProps<T>, RevealProps {
+    /** One dot per datum. */
+    data: readonly T[];
+    /** The value, in data units. Defaults to the datum when `data` is `number[]`. Non-finite values draw no dot. */
+    value?: Channel<T, number>;
+    /** Which group a dot belongs to: a category on the band axis. Omitted, every dot shares one line through the middle. */
+    category?: Channel<T, BandKey>;
+    /**
+     * `"vertical"` puts categories along x and values up y; `"horizontal"` puts values along x.
+     * @default "vertical"
+     */
+    orientation?: "vertical" | "horizontal";
+    /**
+     * Dot radius.
+     * @default 0.07
+     */
+    radius?: number;
+    /** The series each dot belongs to: colours dots through the chart's shared colour scale and legend. `color` wins. */
+    series?: Channel<T, BandKey>;
+    /**
+     * With a `series`: give each series its own sub-band, side by side, within its category's band.
+     * @default false
+     */
+    dodge?: boolean;
+    /** Dot fill, constant or `(d, i) => colour`. Defaults to the `series` colour, else the theme's first series colour. */
+    color?: ColorChannel<T>;
+    /**
+     * Fill opacity, 0..1.
+     * @default 1
+     */
+    fillOpacity?: number;
+    opacity?: number;
+    /**
+     * Reveal, 0..1: each dot fades in place as its radius grows.
+     * @default 1
+     */
+    progress?: number;
+    /** The order `stagger` and `enterStagger` take. @default "position" */
+    staggerOrder?: StaggerOrder;
+    /** Hover tooltip: `true` for a row per channel (`category`, `series`, `value`), or a template, function or options. */
+    tooltip?: TooltipSpec<T>;
+    /** How dots move when `data` changes outside a `to` blend; see {@link MarkTransition}. */
+    transition?: MarkTransition;
+    zIndex?: number;
+    visible?: boolean;
+}
+/**
+ * Props of {@link strip}.
+ *
+ * @category Charts
+ */
+export interface StripProps<T = unknown> extends DotDistributionProps<T> {
+    /**
+     * How far dots spread across their band, as a fraction of it.
+     * @default 0.6
+     */
+    width?: number;
+    /**
+     * What each dot's jitter hashes: something stable about the datum, so dots keep their place
+     * when others come and go. Defaults to its `key` if given, else its index.
+     */
+    jitterKey?: Channel<T, string | number>;
+    /**
+     * Varies the jitter pattern.
+     * @default 0
+     */
+    seed?: number;
+}
+/**
+ * Props of {@link beeswarm}.
+ *
+ * @category Charts
+ */
+export interface BeeswarmProps<T = unknown> extends DotDistributionProps<T> {
+    /**
+     * Extra room between neighbouring dots.
+     * @default 0.01
+     */
+    gap?: number;
+    /**
+     * `"both"` packs the swarm around the band's centre line; `"positive"` stacks it up (or right)
+     * from the band's lower edge, like a dot plot.
+     * @default "both"
+     */
+    side?: "both" | "positive";
+}
+/**
+ * A strip plot: one dot per value, spread across its category's band by seeded jitter so dots
+ * don't pile into a line. The jitter is stable, so scrubbing never reshuffles it. Use
+ * {@link beeswarm} to pack dots without overlap instead. One instances node.
+ *
+ * @example
+ * ```ts
+ * import { chart, strip } from "@sophistry/charts";
+ *
+ * const rows = [
+ * 	{ group: "a", score: 3 },
+ * 	{ group: "a", score: 5 },
+ * 	{ group: "b", score: 4 },
+ * 	{ group: "b", score: 7 },
+ * ];
+ * chart.create({ width: 8, height: 4, children: [strip.create({ data: rows, value: "score", category: "group" })] });
+ * ```
+ *
+ * @see https://sophistry.dev/reference/chart-catalogue/#distributions
+ * @category Charts
+ */
+export declare const strip: import("@sophistry/core").Definition<StripProps<any>, import("@sophistry/core/internal").CompositeNode<StripProps<any>>, keyof StripProps<any>>;
+/**
+ * A beeswarm: one dot per value, each pushed across its band just far enough not to overlap,
+ * so the outline traces the distribution. Dots are packed in scene units, so a swarm re-packs
+ * when the plot is resized. One instances node.
+ *
+ * @example
+ * ```ts
+ * import { beeswarm, chart } from "@sophistry/charts";
+ *
+ * const rows = [
+ * 	{ group: "a", score: 3 },
+ * 	{ group: "a", score: 5 },
+ * 	{ group: "b", score: 4 },
+ * 	{ group: "b", score: 7 },
+ * ];
+ * chart.create({ width: 8, height: 4, children: [beeswarm.create({ data: rows, value: "score", category: "group" })] });
+ * ```
+ *
+ * @see https://sophistry.dev/reference/chart-catalogue/#distributions
+ * @category Charts
+ */
+export declare const beeswarm: import("@sophistry/core").Definition<BeeswarmProps<any>, import("@sophistry/core/internal").CompositeNode<BeeswarmProps<any>>, keyof BeeswarmProps<any>>;
+//# sourceMappingURL=strip.d.ts.map

package/dist/points/strip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strip.d.ts","sourceRoot":"","sources":["../../src/points/strip.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,OAAO,EAAS,MAAM,0BAA0B,CAAC;AAE/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAI/C,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAY,MAAM,kBAAkB,CAAC;AAuBxE,OAAO,KAAK,EAEX,oBAAoB,EACpB,WAAW,EACX,YAAY,EACZ,MAAM,UAAU,CAAC;AAGlB,OAAO,KAAK,EAAE,WAAW,EAAgB,MAAM,YAAY,CAAC;AAQ5D;;;;GAIG;AACH,MAAM,WAAW,oBAAoB,CAAC,CAAC,CACtC,SAAQ,oBAAoB,CAAC,CAAC,CAAC,EAC9B,WAAW;IACZ,yBAAyB;IACzB,IAAI,EAAE,SAAS,CAAC,EAAE,CAAC;IACnB,gHAAgH;IAChH,KAAK,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;IAC3B,wHAAwH;IACxH,QAAQ,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IAC/B;;;OAGG;IACH,WAAW,CAAC,EAAE,UAAU,GAAG,YAAY,CAAC;IACxC;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qHAAqH;IACrH,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IAC7B;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,uHAAuH;IACvH,KAAK,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;IACxB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,uEAAuE;IACvE,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,uHAAuH;IACvH,OAAO,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IACzB,0FAA0F;IAC1F,UAAU,CAAC,EAAE,cAAc,CAAC;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC,GAAG,OAAO,CAAE,SAAQ,oBAAoB,CAAC,CAAC,CAAC;IACvE;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;IACxC;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC,GAAG,OAAO,CAAE,SAAQ,oBAAoB,CAAC,CAAC,CAAC;IAC1E;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC;CAC3B;AAiiBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,KAAK,iJAUhB,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,QAAQ,0JASnB,CAAC"}