@rokkit/chart 1.6.0 → 1.8.0

package/dist/lib/region.js

@@ -0,0 +1,127 @@
+/**
+ * Region geometry — data-coordinate shapes resolved to plot (u, v) coordinates.
+ *
+ * Kept out of the component so the maths is testable without a DOM, and so every geom that
+ * needs "a shape in data space" (Region today, anything shaded tomorrow) resolves it the same
+ * way: continuous values map straight through the scale, band categories cover the WHOLE
+ * band, and an omitted range spans the axis.
+ */
+
+/** @typedef {{ (v: unknown): number | undefined, bandwidth?: () => number, range: () => number[], domain: () => unknown[] }} AnyScale */
+
+/** @param {AnyScale} scale */
+const isBand = (scale) => typeof scale.bandwidth === 'function'
+
+/**
+ * The data value an open (null/undefined) range end stands for: the low or high end of the
+ * axis's domain — the first or last category on a band axis.
+ *
+ * @param {AnyScale} scale
+ * @param {unknown} v
+ * @param {'lo' | 'hi'} side
+ */
+function endValue(scale, v, side) {
+	if (v !== null && v !== undefined) return v
+	const domain = scale.domain()
+	if (isBand(scale)) return side === 'lo' ? domain[0] : domain[domain.length - 1]
+	const nums = domain.map(Number)
+	return side === 'lo' ? Math.min(...nums) : Math.max(...nums)
+}
+
+/**
+ * Screen span of a [lo, hi] range on one axis. A band category contributes its whole band,
+ * so `x={['a', 'b']}` shades both columns edge to edge. Omitted → the full range; a `null`
+ * end runs to that edge of the axis, so `[p75, null]` is "the top quartile and beyond".
+ *
+ * @param {AnyScale} scale
+ * @param {unknown[] | undefined} range
+ * @returns {[number, number]}
+ */
+export function spanOf(scale, range) {
+	if (!range || range.length < 2) {
+		const r = scale.range()
+		return [Math.min(...r), Math.max(...r)]
+	}
+	const band = isBand(scale) ? /** @type {() => number} */ (scale.bandwidth)() : 0
+	const ends = [endValue(scale, range[0], 'lo'), endValue(scale, range[1], 'hi')].map((v) =>
+		Number(scale(v))
+	)
+	return [Math.min(...ends), Math.max(...ends) + band]
+}
+
+/**
+ * Position of a single data value — band categories resolve to the band centre, which is
+ * where a point in that category is drawn.
+ *
+ * @param {AnyScale} scale
+ * @param {unknown} v
+ */
+export function positionOf(scale, v) {
+	const base = Number(scale(v))
+	return isBand(scale) ? base + /** @type {() => number} */ (scale.bandwidth)() / 2 : base
+}
+
+/**
+ * The region's vertices in (u, v) plot coordinates — before orientation `place`.
+ *
+ * `points` (a polygon, three or more vertices) wins over `x`/`y` ranges. Fewer than three
+ * points is not an area, so it resolves to nothing rather than a degenerate sliver.
+ *
+ * @param {{ x?: unknown[], y?: unknown[], points?: unknown[][] }} shape
+ * @param {AnyScale} xScale
+ * @param {AnyScale} yScale
+ * @returns {Array<[number, number]>}
+ */
+export function regionVertices(shape, xScale, yScale) {
+	if (shape.points) {
+		if (shape.points.length < 3) return []
+		return shape.points.map(([x, y]) => [positionOf(xScale, x), positionOf(yScale, y)])
+	}
+	if (!shape.x && !shape.y) return []
+	const [x0, x1] = spanOf(xScale, shape.x)
+	const [y0, y1] = spanOf(yScale, shape.y)
+	// Wound so the first vertex is the (lo-x, lo-y) corner in DATA terms: on a vertical chart
+	// the y range is inverted, so y1 (the larger pixel) is the lower value.
+	return [
+		[x0, y1],
+		[x1, y1],
+		[x1, y0],
+		[x0, y0]
+	]
+}
+
+/**
+ * Area centroid of a simple polygon — where its label goes. Falls back to the vertex mean for
+ * a zero-area (collinear) polygon, which has no area centroid.
+ *
+ * @param {Array<{ x: number, y: number }>} pts
+ * @returns {{ x: number, y: number }}
+ */
+export function centroid(pts) {
+	let a = 0
+	let cx = 0
+	let cy = 0
+	for (let i = 0; i < pts.length; i++) {
+		const p = pts[i]
+		const q = pts[(i + 1) % pts.length]
+		const cross = p.x * q.y - q.x * p.y
+		a += cross
+		cx += (p.x + q.x) * cross
+		cy += (p.y + q.y) * cross
+	}
+	if (Math.abs(a) < 1e-9) {
+		const n = pts.length || 1
+		return { x: pts.reduce((s, p) => s + p.x, 0) / n, y: pts.reduce((s, p) => s + p.y, 0) / n }
+	}
+	return { x: cx / (3 * a), y: cy / (3 * a) }
+}
+
+/**
+ * SVG path data for a closed polygon.
+ *
+ * @param {Array<{ x: number, y: number }>} pts
+ */
+export function polygonPath(pts) {
+	const fmt = (/** @type {number} */ n) => Math.round(n * 1000) / 1000
+	return `M${pts.map((p) => `${fmt(p.x)},${fmt(p.y)}`).join(' L')} Z`
+}

package/dist/lib/swatch.d.ts

@@ -7,6 +7,6 @@ export namespace swatch {
         export { PATTERN_ORDER as pattern };
     }
 }
-import palette from './palette.json';
+import { categoricalPalette as palette } from '@rokkit/core';
 import { shapes } from '../symbols';
 import { PATTERN_ORDER } from './brewing/patterns.js';

package/dist/lib/swatch.js

@@ -1,4 +1,4 @@
-import palette from './palette.json'
+import { categoricalPalette as palette } from '@rokkit/core'
 import { PATTERN_ORDER } from './brewing/patterns.js'
 import { shapes } from '../symbols'
 

package/dist/state/AestheticState.svelte.d.ts

@@ -0,0 +1,43 @@
+/**
+ * What each category looks like: its palette entry, pattern and symbol — and, for a numeric
+ * colour field, the continuous (sequential or diverging) colour scale.
+ */
+export class AestheticState {
+    /**
+     * @param {import('./PlotConfig.svelte.js').PlotConfig} config
+     * @param {import('./ChannelState.svelte.js').ChannelState} channels
+     */
+    constructor(config: import("./PlotConfig.svelte.js").PlotConfig, channels: import("./ChannelState.svelte.js").ChannelState);
+    /** 'categorical' | 'sequential' | 'diverging' — inferred from the colour field and the spec. */
+    colorScaleType: any;
+    /** The sequential or diverging colour scale, or null for a categorical colour field. */
+    continuousColorScale: {
+        scale: (v: number) => string;
+        domain: [number, number];
+        type: "sequential";
+    } | {
+        scale: (v: number) => string;
+        domain: [number, number, number];
+        type: "diverging";
+    } | null;
+    /**
+     * Map<category, { fill, stroke }> — one shared palette across the colour and fill channels.
+     *
+     * A literal CSS colour is a singleton keyed by null, which every mark falls back to. A
+     * `colorDomain` (FacetPlot passes one so panels agree) wins over the local categories. With
+     * no colour field at all, a single series takes the first palette entry rather than grey.
+     */
+    colors: Map<unknown, {
+        fill: string;
+        stroke: string;
+    }> | Map<null, {
+        fill: any;
+        stroke: any;
+    }>;
+    /** Map<category, pattern name> — only for a categorical pattern field. */
+    patterns: Map<unknown, string> | SvelteMap<any, any>;
+    /** Map<category, symbol shape>. */
+    symbols: Map<unknown, string> | SvelteMap<any, any>;
+    #private;
+}
+import { SvelteMap } from 'svelte/reactivity';

package/dist/state/AestheticState.svelte.js

@@ -0,0 +1,84 @@
+import { SvelteMap } from 'svelte/reactivity'
+import { inferFieldType, inferColorScaleType } from '../lib/plot/scales.js'
+import {
+	distinct,
+	assignColors,
+	isLiteralColor,
+	buildSequentialScale,
+	buildDivergingScale
+} from '../lib/brewing/colors.js'
+import { assignPatterns } from '../lib/brewing/patterns.js'
+import { assignSymbols } from '../lib/brewing/marks/points.js'
+
+/**
+ * What each category looks like: its palette entry, pattern and symbol — and, for a numeric
+ * colour field, the continuous (sequential or diverging) colour scale.
+ */
+export class AestheticState {
+	#config
+	#channels
+
+	/**
+	 * @param {import('./PlotConfig.svelte.js').PlotConfig} config
+	 * @param {import('./ChannelState.svelte.js').ChannelState} channels
+	 */
+	constructor(config, channels) {
+		this.#config = config
+		this.#channels = channels
+	}
+
+	/** 'categorical' | 'sequential' | 'diverging' — inferred from the colour field and the spec. */
+	colorScaleType = $derived.by(() => {
+		const field = this.#channels.effective.color
+		if (!field) return 'categorical'
+		return inferColorScaleType(this.#config.data, field, {
+			colorScale: this.#config.colorScale,
+			colorMidpoint: this.#config.colorMidpoint
+		})
+	})
+
+	/** The sequential or diverging colour scale, or null for a categorical colour field. */
+	continuousColorScale = $derived.by(() => {
+		const field = this.#channels.effective.color
+		if (!field || this.colorScaleType === 'categorical') return null
+		const opts = {
+			colorScheme: this.#config.colorScheme,
+			colorDomain: this.#config.colorDomain,
+			colorMidpoint: this.#config.colorMidpoint
+		}
+		const build = this.colorScaleType === 'diverging' ? buildDivergingScale : buildSequentialScale
+		return build(this.#config.data, field, opts)
+	})
+
+	/**
+	 * Map<category, { fill, stroke }> — one shared palette across the colour and fill channels.
+	 *
+	 * A literal CSS colour is a singleton keyed by null, which every mark falls back to. A
+	 * `colorDomain` (FacetPlot passes one so panels agree) wins over the local categories. With
+	 * no colour field at all, a single series takes the first palette entry rather than grey.
+	 */
+	colors = $derived.by(() => {
+		const field = this.#channels.effective.color
+		if (isLiteralColor(field)) {
+			// eslint-disable-next-line svelte/prefer-svelte-reactivity -- a derived value, rebuilt whole; nothing mutates it
+			return new Map([[null, { fill: field, stroke: field }]])
+		}
+		const values = this.#config.colorDomain ?? this.#channels.colorValues
+		const keys = values.length === 0 && this.#config.data.length > 0 ? [null] : values
+		return assignColors(keys, this.#config.mode, this.#config.chartPreset)
+	})
+
+	/** Map<category, pattern name> — only for a categorical pattern field. */
+	patterns = $derived.by(() => {
+		const pf = this.#channels.effective.pattern
+		if (!pf || inferFieldType(this.#config.data, pf) === 'continuous') return new SvelteMap()
+		return assignPatterns(distinct(this.#config.data, pf))
+	})
+
+	/** Map<category, symbol shape>. */
+	symbols = $derived.by(() => {
+		const sf = this.#channels.effective.symbol
+		if (!sf) return new SvelteMap()
+		return assignSymbols(distinct(this.#config.data, sf), this.#config.chartPreset)
+	})
+}

package/dist/state/AxisState.svelte.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Where the axes cross, in screen coordinates.
+ *
+ * At an explicit `axisOrigin` (a BCG or risk matrix); else at zero when the domain spans it
+ * (two- and four-quadrant charts fall out of where zero sits); else pinned to the bottom / left
+ * edge, pushed outward by `axisOffset`. A band x axis always pins left.
+ */
+export class AxisState {
+    /**
+     * @param {import('./PlotConfig.svelte.js').PlotConfig} config
+     * @param {{ x: any, y: any }} scales
+     * @param {{ innerWidth: number, innerHeight: number }} frame
+     */
+    constructor(config: import("./PlotConfig.svelte.js").PlotConfig, scales: {
+        x: any;
+        y: any;
+    }, frame: {
+        innerWidth: number;
+        innerHeight: number;
+    });
+    /** The x axis's screen y. */
+    xAxisY: any;
+    /** The y axis's screen x. */
+    yAxisX: any;
+    #private;
+}

package/dist/state/AxisState.svelte.js

@@ -0,0 +1,56 @@
+/**
+ * Where the axes cross, in screen coordinates.
+ *
+ * At an explicit `axisOrigin` (a BCG or risk matrix); else at zero when the domain spans it
+ * (two- and four-quadrant charts fall out of where zero sits); else pinned to the bottom / left
+ * edge, pushed outward by `axisOffset`. A band x axis always pins left.
+ */
+export class AxisState {
+	#config
+	#scales
+	#frame
+
+	/**
+	 * @param {import('./PlotConfig.svelte.js').PlotConfig} config
+	 * @param {{ x: any, y: any }} scales
+	 * @param {{ innerWidth: number, innerHeight: number }} frame
+	 */
+	constructor(config, scales, frame) {
+		this.#config = config
+		this.#scales = scales
+		this.#frame = frame
+	}
+
+	/** The x axis's screen y. */
+	xAxisY = $derived.by(() => {
+		const y = this.#scales.y
+		if (typeof y !== 'function') return this.#frame.innerHeight
+		const cross = this.#config.axisOrigin[1]
+		if (cross !== undefined) return y(cross)
+		const domain = y.domain()
+		if (domain[0] <= 0 && domain[domain.length - 1] >= 0) return y(0)
+		return this.#offset(y(domain[0]), 1)
+	})
+
+	/** The y axis's screen x. */
+	yAxisX = $derived.by(() => {
+		const x = this.#scales.x
+		if (typeof x !== 'function') return 0
+		const cross = this.#config.axisOrigin[0]
+		if (cross !== undefined) return x(cross)
+		if (typeof x.bandwidth === 'function') return 0
+		const domain = x.domain()
+		if (domain[0] <= 0 && domain[domain.length - 1] >= 0) return x(0)
+		return this.#offset(x(domain[0]), -1)
+	})
+
+	/**
+	 * Push an edge-pinned axis outward by `axisOffset`. Only when there IS an offset: a scale with
+	 * an empty domain (a race's first frame, before any rows) returns undefined, and
+	 * `undefined + 0` is NaN — which lands in the axis transform as `translate(NaN, 0)`.
+	 */
+	#offset(base, direction) {
+		const offset = this.#config.axisOffset
+		return offset ? base + direction * offset : base
+	}
+}

package/dist/state/ChannelState.svelte.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Which data field feeds each aesthetic, once the container and its geoms are merged.
+ */
+export class ChannelState {
+    /**
+     * @param {import('./PlotConfig.svelte.js').PlotConfig} config
+     * @param {import('./GeomRegistry.svelte.js').GeomRegistry} geoms
+     */
+    constructor(config: import("./PlotConfig.svelte.js").PlotConfig, geoms: import("./GeomRegistry.svelte.js").GeomRegistry);
+    /**
+     * The container's channels, with each field it omits taken from the FIRST geom — per field,
+     * not all-or-nothing, so a `<Plot.Root x y>` that omits `color` still picks up
+     * `<Plot.Box color=x>`'s, and the palette gets per-category entries instead of grey.
+     */
+    effective: import("./PlotConfig.svelte.js").Channels | {
+        [k: string]: any;
+    };
+    /** The colour field, or null when `color` is a literal CSS colour rather than a field. */
+    colorField: any;
+    /** The fill field, or null for a literal colour. */
+    fillField: any;
+    patternField: any;
+    symbolField: any;
+    /**
+     * The category values feeding ONE shared palette and legend: every `color` and `fill` field
+     * of the container and of every geom (literal colours excluded), their values unioned in
+     * order. See docs/backlog/2026-08-17-chart-aesthetics-unification.md §2.
+     *
+     * `includes` rather than a Set: a domain of dozens of categories, not rows, so the scan
+     * costs nothing and there is no collection for the reactivity linter to flag.
+     */
+    colorValues: unknown[];
+    #private;
+}

package/dist/state/ChannelState.svelte.js

@@ -0,0 +1,67 @@
+import { distinct, isLiteralColor } from '../lib/brewing/colors.js'
+
+/** The positional and aesthetic channels a container can inherit from its first geom. */
+const INHERITED = ['x', 'y', 'color', 'fill', 'pattern', 'symbol']
+
+/**
+ * Which data field feeds each aesthetic, once the container and its geoms are merged.
+ */
+export class ChannelState {
+	#config
+	#geoms
+
+	/**
+	 * @param {import('./PlotConfig.svelte.js').PlotConfig} config
+	 * @param {import('./GeomRegistry.svelte.js').GeomRegistry} geoms
+	 */
+	constructor(config, geoms) {
+		this.#config = config
+		this.#geoms = geoms
+	}
+
+	/**
+	 * The container's channels, with each field it omits taken from the FIRST geom — per field,
+	 * not all-or-nothing, so a `<Plot.Root x y>` that omits `color` still picks up
+	 * `<Plot.Box color=x>`'s, and the palette gets per-category entries instead of grey.
+	 */
+	effective = $derived.by(() => {
+		const tc = this.#config.channels
+		const geom = this.#geoms.first
+		if (!geom) return tc
+		const own = geom.channels ?? {}
+		return Object.fromEntries(INHERITED.map((key) => [key, tc[key] ?? own[key]]))
+	})
+
+	/** The colour field, or null when `color` is a literal CSS colour rather than a field. */
+	colorField = $derived(isLiteralColor(this.effective.color) ? null : this.effective.color)
+	/** The fill field, or null for a literal colour. */
+	fillField = $derived(isLiteralColor(this.effective.fill) ? null : this.effective.fill)
+	patternField = $derived(this.effective.pattern)
+	symbolField = $derived(this.effective.symbol)
+
+	/**
+	 * The category values feeding ONE shared palette and legend: every `color` and `fill` field
+	 * of the container and of every geom (literal colours excluded), their values unioned in
+	 * order. See docs/backlog/2026-08-17-chart-aesthetics-unification.md §2.
+	 *
+	 * `includes` rather than a Set: a domain of dozens of categories, not rows, so the scan
+	 * costs nothing and there is no collection for the reactivity linter to flag.
+	 */
+	colorValues = $derived.by(() => {
+		const fields = []
+		const add = (f) => {
+			if (f && !isLiteralColor(f) && !fields.includes(f)) fields.push(f)
+		}
+		add(this.#config.channels.color)
+		add(this.#config.channels.fill)
+		for (const g of this.#geoms.list) {
+			add(g.channels?.color)
+			add(g.channels?.fill)
+		}
+		const values = []
+		for (const f of fields) {
+			for (const v of distinct(this.#config.data, f)) if (!values.includes(v)) values.push(v)
+		}
+		return values
+	})
+}

package/dist/state/GeomRegistry.svelte.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The geoms mounted in one plot, and the rows each one draws.
+ *
+ * Shared by `PlotState` and `SparkState`, which used to carry a copy each — and so needed the
+ * undefined-channel fix below made twice. `source` is whatever owns the rows and the container
+ * channels: `{ data, channels, helpers? }`, read live through its getters.
+ */
+export class GeomRegistry {
+    /**
+     * @param {{ data: Record<string, unknown>[], channels: Record<string, string | undefined>, helpers?: Record<string, unknown> }} source
+     * @param {string} [prefix] - id prefix, so a plot's geom ids and a spark's never collide
+     */
+    constructor(source: {
+        data: Record<string, unknown>[];
+        channels: Record<string, string | undefined>;
+        helpers?: Record<string, unknown>;
+    }, prefix?: string);
+    /** Every mounted geom's config, in mount order. */
+    get list(): any[];
+    /** The first mounted geom — the one a container without channels borrows them from. */
+    get first(): any;
+    /** Distinct geom types mounted (the legend picks a swatch style from these). */
+    types: SvelteSet<any>;
+    /** @param {(g: any) => boolean} predicate */
+    find(predicate: (g: any) => boolean): any;
+    /** Called once per geom from its onMount; the returned id is its handle. */
+    register(config: any): string;
+    /**
+     * Called from a geom's `$effect`. The read of the list is untracked: tracked, the effect
+     * would re-run on its own write (effect_update_depth_exceeded).
+     */
+    update(id: any, config: any): void;
+    /** Called from a geom's onDestroy, which Svelte runs outside any tracking scope. */
+    unregister(id: any): void;
+    /**
+     * The rows one geom draws.
+     *
+     * Identity stat returns the source rows THEMSELVES, not a copy: geoms look a row up with
+     * `plotState.data.indexOf(row)`, which only matches the same object.
+     */
+    data(id: any): Object[];
+    #private;
+}
+import { SvelteSet } from 'svelte/reactivity';

package/dist/state/GeomRegistry.svelte.js

@@ -0,0 +1,86 @@
+import { untrack } from 'svelte'
+import { SvelteSet } from 'svelte/reactivity'
+import { applyGeomStat } from '../lib/plot/stat.js'
+
+/** Module-wide so ids stay unique across every plot and spark on the page. */
+let nextId = 0
+
+/**
+ * The geoms mounted in one plot, and the rows each one draws.
+ *
+ * Shared by `PlotState` and `SparkState`, which used to carry a copy each — and so needed the
+ * undefined-channel fix below made twice. `source` is whatever owns the rows and the container
+ * channels: `{ data, channels, helpers? }`, read live through its getters.
+ */
+export class GeomRegistry {
+	#source
+	#prefix
+	#geoms = $state([])
+
+	/**
+	 * @param {{ data: Record<string, unknown>[], channels: Record<string, string | undefined>, helpers?: Record<string, unknown> }} source
+	 * @param {string} [prefix] - id prefix, so a plot's geom ids and a spark's never collide
+	 */
+	constructor(source, prefix = 'geom') {
+		this.#source = source
+		this.#prefix = prefix
+	}
+
+	/** Every mounted geom's config, in mount order. */
+	get list() {
+		return this.#geoms
+	}
+	/** The first mounted geom — the one a container without channels borrows them from. */
+	get first() {
+		return this.#geoms[0]
+	}
+	/** Distinct geom types mounted (the legend picks a swatch style from these). */
+	types = $derived(new SvelteSet(this.#geoms.map((g) => g.type)))
+
+	/** @param {(g: any) => boolean} predicate */
+	find(predicate) {
+		return this.#geoms.find(predicate)
+	}
+
+	/** Called once per geom from its onMount; the returned id is its handle. */
+	register(config) {
+		const id = `${this.#prefix}-${nextId++}`
+		this.#geoms = [...this.#geoms, { id, ...config }]
+		return id
+	}
+
+	/**
+	 * Called from a geom's `$effect`. The read of the list is untracked: tracked, the effect
+	 * would re-run on its own write (effect_update_depth_exceeded).
+	 */
+	update(id, config) {
+		this.#geoms = untrack(() => this.#geoms).map((g) => (g.id === id ? { ...g, ...config } : g))
+	}
+
+	/** Called from a geom's onDestroy, which Svelte runs outside any tracking scope. */
+	unregister(id) {
+		this.#geoms = this.#geoms.filter((g) => g.id !== id)
+	}
+
+	/**
+	 * The rows one geom draws.
+	 *
+	 * Identity stat returns the source rows THEMSELVES, not a copy: geoms look a row up with
+	 * `plotState.data.indexOf(row)`, which only matches the same object.
+	 */
+	data(id) {
+		const geom = this.#geoms.find((g) => g.id === id)
+		if (!geom) return []
+		const stat = geom.stat ?? 'identity'
+		const rows = this.#source.data
+		if (stat === 'identity') return rows
+		// A geom that omits a channel to inherit it from the container sends
+		// `{ x: undefined }`, not `{}`. Spread as-is, that own `undefined` would clobber the
+		// container's value and the stat would silently fall back to identity.
+		const geomChannels = Object.fromEntries(
+			Object.entries(geom.channels ?? {}).filter(([, v]) => v !== undefined)
+		)
+		const channels = { ...this.#source.channels, ...geomChannels }
+		return applyGeomStat(rows, { stat, channels }, this.#source.helpers)
+	}
+}

package/dist/state/InteractionState.svelte.d.ts

@@ -0,0 +1,30 @@
+/**
+ * What the reader is doing to the chart: the hovered row, the selected rows, the zoom.
+ *
+ * The selection is a set of ROW objects, compared by identity — they must be the rows the
+ * geoms were handed (`PlotState.data`), which is why the plot keeps one proxy for its data.
+ */
+export class InteractionState {
+    /**
+     * @param {import('./PlotConfig.svelte.js').PlotConfig} config
+     * @param {unknown[]} [selected] - the initial selection; afterwards the caller drives it
+     *   through `setSelected` (PlotSurface syncs its bindable prop that way)
+     */
+    constructor(config: import("./PlotConfig.svelte.js").PlotConfig, selected?: unknown[]);
+    get hovered(): null;
+    setHovered(row: any): void;
+    clearHovered(): void;
+    /** Marks are clickable: the caller listens, or selection is on. */
+    get interactive(): boolean;
+    get selectedRows(): any[];
+    isSelected(row: any): boolean;
+    setSelected(rows: any): void;
+    clearSelected(): void;
+    /** An activation: always reported; toggles the row in the selection when selectable. */
+    handleSelect(detail: any): void;
+    /** The d3-zoom transform, or null at rest. Scales rescale through it. */
+    get zoom(): null;
+    applyZoom(transform: any): void;
+    resetZoom(): void;
+    #private;
+}