@rokkit/chart 1.4.0 → 1.4.1

package/dist/PlotState.svelte.js

@@ -94,15 +94,13 @@ export class PlotState {
 			addField(g.channels?.color)
 			addField(g.channels?.fill)
 		}
-		const seen = new Set()
+		// `includes` dedup rather than a Set, matching `addField` above. These are
+		// category values feeding one palette/legend — a domain of dozens, not
+		// rows — so the linear scan costs nothing and the function stays free of
+		// a collection the reactivity linter has to be told to ignore.
 		const values = []
 		for (const f of fields) {
-			for (const v of distinct(this.#data, f)) {
-				if (!seen.has(v)) {
-					seen.add(v)
-					values.push(v)
-				}
-			}
+			for (const v of distinct(this.#data, f)) if (!values.includes(v)) values.push(v)
 		}
 		return values
 	}
@@ -126,6 +124,12 @@ export class PlotState {
 		const xf = this.#effectiveChannels.x
 		const yf = this.#effectiveChannels.y
 		if (!xf || !yf) return null
+		// Keyed accumulator, function-local and discarded before returning — a
+		// SvelteMap would register a reactive signal per category on every
+		// derivation for a collection nothing outside this call can observe.
+		// Not a plain object either: keys are raw data values (numbers, Dates),
+		// which object keys would coerce to strings.
+		// eslint-disable-next-line svelte/prefer-svelte-reactivity
 		const totals = new Map()
 		for (const ds of datasets) {
 			for (const d of ds) {

package/dist/Sparkline.svelte

@@ -84,13 +84,11 @@
 				? []
 				: [highlight]
 	)
-	const highlightIndices = $derived.by(() => {
-		const seen = new Set<number>()
-		for (const sel of highlightSelectors) {
-			for (const i of resolveHighlight(rows, sel, { y: 'y' })) seen.add(i)
-		}
-		return seen
-	})
+	// `resolveHighlight` returns number[], so the union is a flatMap and the Set is
+	// built from that iterable — no incremental .add() to make reactive.
+	const highlightIndices = $derived(
+		new Set<number>(highlightSelectors.flatMap((sel) => resolveHighlight(rows, sel, { y: 'y' })))
+	)
 	const highlightPredicate = $derived(
 		highlightIndices.size > 0
 			? (_row: Record<string, unknown>, i: number) => highlightIndices.has(i)

package/dist/geoms/Area.svelte

@@ -66,14 +66,14 @@
 	function selectPoint(d: Row, event: MouseEvent | KeyboardEvent) {
 		if (plotState.interactive)
 			plotState.handleSelect(
-				buildSelectDetail(
-					d,
-					plotState.data.indexOf(d),
-					{ x, y },
-					'area',
-					seriesField ? d[seriesField] : undefined,
+				buildSelectDetail({
+					datum: d,
+					index: plotState.data.indexOf(d),
+					channels: { x, y },
+					geom: 'area',
+					series: seriesField ? d[seriesField] : undefined,
 					event
-				)
+				})
 			)
 	}
 </script>

package/dist/geoms/Bar.svelte

@@ -119,14 +119,14 @@
 	function selectBar(bar: { data: Row }, event: MouseEvent | KeyboardEvent) {
 		if (plotState.interactive)
 			plotState.handleSelect(
-				buildSelectDetail(
-					bar.data,
-					plotState.data.indexOf(bar.data),
-					{ x, y },
-					'bar',
-					seriesField ? bar.data[seriesField] : undefined,
+				buildSelectDetail({
+					datum: bar.data,
+					index: plotState.data.indexOf(bar.data),
+					channels: { x, y },
+					geom: 'bar',
+					series: seriesField ? bar.data[seriesField] : undefined,
 					event
-				)
+				})
 			)
 	}
 

package/dist/geoms/Highlight.svelte

@@ -16,43 +16,69 @@
 
 	const state = getContext<PlotState>('plot-state')
 
-	const marks = $derived.by(() => {
-		const rows = state?.data ?? []
-		const xs = state?.xScale
-		const ys = state?.yScale
-		if (!xs || !ys || !x || !y) return []
-		const selectedRows = state?.selectedRows ?? []
-		const selectedSet = new Set(selectedRows)
-		const out = []
-		const seen = new Set()
-		if (highlight !== null && highlight !== undefined && rows.length) {
-			for (const i of resolveHighlight(rows, highlight, { y })) {
-				const row = rows[i]
-				out.push({
-					key: `h${i}`,
-					cx: scalePos(xs, row[x]),
-					cy: ys(Number(row[y])),
-					row,
-					// A statically-highlighted point that is also selected renders as
-					// selected — selection is the stronger, interactive state.
-					selected: selectedSet.has(row)
-				})
-				seen.add(row)
-			}
+	type Mark = { key: string; cx: number; cy: number; row: Row; selected: boolean }
+	/** Everything both mark builders need, resolved once per derivation. */
+	type Ctx = {
+		rows: Row[]
+		selectedRows: Row[]
+		// Scales come from PlotState (untyped JS), so they stay loose here.
+		xs: (v: unknown) => number
+		ys: (v: number) => number
+		x: string
+		y: string
+	}
+
+	const hasScales = (s: PlotState | undefined) => Boolean(s?.xScale && s?.yScale)
+
+	/** Null until the plot has both scales and both channels — nothing can be placed before then. */
+	const ctx = $derived.by((): Ctx | null => {
+		if (!hasScales(state) || !x || !y) return null
+		return {
+			rows: state.data ?? [],
+			selectedRows: state.selectedRows ?? [],
+			xs: state.xScale,
+			ys: state.yScale,
+			x,
+			y
 		}
-		selectedRows.forEach((row, j) => {
-			if (seen.has(row)) return
-			out.push({
-				key: `s${j}`,
-				cx: scalePos(xs, row[x]),
-				cy: ys(Number(row[y])),
-				row,
-				selected: true
-			})
-		})
-		return out.filter((m) => Number.isFinite(m.cx) && Number.isFinite(m.cy))
 	})
 
+	const place = (c: Ctx, row: Row) => ({
+		cx: scalePos(c.xs, row[c.x]),
+		cy: c.ys(Number(row[c.y]))
+	})
+
+	/** Marks for the declarative `highlight` selector. */
+	function highlightMarks(c: Ctx, selector: Props['highlight']): Mark[] {
+		if (selector === null || selector === undefined) return []
+		const selected = new Set(c.selectedRows)
+		return resolveHighlight(c.rows, selector, { y: c.y }).map((i) => ({
+			key: `h${i}`,
+			...place(c, c.rows[i]),
+			row: c.rows[i],
+			// A statically-highlighted point that is also selected renders as
+			// selected — selection is the stronger, interactive state.
+			selected: selected.has(c.rows[i])
+		}))
+	}
+
+	/** Marks for interactive selection, minus any row a highlight mark already covers. */
+	function selectionMarks(c: Ctx, covered: Set<Row>): Mark[] {
+		return c.selectedRows
+			.map((row, j) => ({ row, j }))
+			.filter(({ row }) => !covered.has(row))
+			.map(({ row, j }) => ({ key: `s${j}`, ...place(c, row), row, selected: true }))
+	}
+
+	const isPlaced = (m: Mark) => Number.isFinite(m.cx) && Number.isFinite(m.cy)
+
+	const marks = $derived.by(() => {
+		if (!ctx) return []
+		const highlighted = highlightMarks(ctx, highlight)
+		// Derived from the marks just built, so "already emitted" has one source of truth.
+		const selected = selectionMarks(ctx, new Set(highlighted.map((m) => m.row)))
+		return [...highlighted, ...selected].filter(isPlaced)
+	})
 </script>
 
 {#if marks.length}

package/dist/geoms/Line.svelte

@@ -75,7 +75,14 @@
 		onselect?.(pt.data)
 		if (plotState.interactive)
 			plotState.handleSelect(
-				buildSelectDetail(pt.data, plotState.data.indexOf(pt.data), { x, y }, 'line', seg?.key, event)
+				buildSelectDetail({
+					datum: pt.data,
+					index: plotState.data.indexOf(pt.data),
+					channels: { x, y },
+					geom: 'line',
+					series: seg?.key,
+					event
+				})
 			)
 	}
 </script>

package/dist/geoms/Point.svelte

@@ -74,14 +74,14 @@
 		onselect?.(pt.data)
 		if (plotState.interactive)
 			plotState.handleSelect(
-				buildSelectDetail(
-					pt.data,
-					plotState.data.indexOf(pt.data),
-					{ x, y },
-					'point',
-					seriesField ? pt.data[seriesField] : undefined,
+				buildSelectDetail({
+					datum: pt.data,
+					index: plotState.data.indexOf(pt.data),
+					channels: { x, y },
+					geom: 'point',
+					series: seriesField ? pt.data[seriesField] : undefined,
 					event
-				)
+				})
 			)
 	}
 </script>

package/dist/geoms/Radar.svelte

@@ -183,16 +183,16 @@
 		onselect?.(row)
 		if (plotState.interactive)
 			plotState.handleSelect(
-				buildSelectDetail(
-					row,
+				buildSelectDetail({
+					datum: row,
 					// `row` is one of the container's original row objects — averaging happens
 					// inside polar.js precisely so this lookup resolves instead of returning -1.
-					plotState.data.indexOf(row),
-					{ x: axis, y: value },
-					'radar',
-					seriesKey,
+					index: plotState.data.indexOf(row),
+					channels: { x: axis, y: value },
+					geom: 'radar',
+					series: seriesKey,
 					event
-				)
+				})
 			)
 	}
 

package/dist/geoms/Trend.svelte

@@ -20,30 +20,53 @@
 		return t === 'mean' ? 'avg' : t
 	}
 
+	/** Everything a path builder needs, resolved once per derivation. */
+	type Ctx = {
+		rows: Record<string, unknown>[]
+		// Scales come from PlotState (untyped JS), so they stay loose here.
+		xs: (v: unknown) => number
+		ys: (v: number) => number
+		x: string
+		y: string
+		innerWidth: number
+	}
+
+	const isDrawable = (s: PlotState | undefined) =>
+		Boolean(s?.xScale && s?.yScale && s?.data?.length)
+
+	/** Null until the plot has data, both scales, both channels and at least one method. */
+	const ctx = $derived.by((): Ctx | null => {
+		if (!isDrawable(state) || !x || !y || !methods.length) return null
+		return { rows: state.data, xs: state.xScale, ys: state.yScale, x, y, innerWidth: state.innerWidth }
+	})
+
+	/** A flat rule spanning the plot — what every `constant` trend (avg, median, min…) draws. */
+	const constantPath = (c: Ctx, value: number) => {
+		const yy = c.ys(value)
+		return `M0,${yy} L${c.innerWidth},${yy}`
+	}
+
+	/** A polyline through the trend's per-row values, dropping points that don't place. */
+	function seriesPath(c: Ctx, values: number[]): string | null {
+		const pts = values
+			.map((v, i) => ({ vx: scalePos(c.xs, c.rows[i][c.x]), vy: c.ys(v) }))
+			.filter((p) => Number.isFinite(p.vx) && Number.isFinite(p.vy))
+		return d3line<{ vx: number; vy: number }>()
+			.x((p) => p.vx)
+			.y((p) => p.vy)(pts)
+	}
+
+	/** One method → one path, or null when the method doesn't resolve for this data. */
+	function trendPath(c: Ctx, m: Method, i: number) {
+		const res = computeTrend(c.rows, { x: c.x, y: c.y }, m)
+		if (!res) return null
+		const d = res.kind === 'constant' ? constantPath(c, res.value) : seriesPath(c, res.values)
+		return d ? { d, type: typeOf(m), i } : null
+	}
+
 	const paths = $derived.by(() => {
-		const rows = state?.data ?? []
-		const xs = state?.xScale
-		const ys = state?.yScale
-		if (!rows.length || !xs || !ys || !x || !y || !methods.length) return []
-		const out: { d: string; type: string; i: number }[] = []
-		methods.forEach((m, idx) => {
-			const res = computeTrend(rows, { x, y }, m)
-			if (!res) return
-			if (res.kind === 'constant') {
-				const yy = ys(res.value)
-				out.push({ d: `M0,${yy} L${state.innerWidth},${yy}`, type: typeOf(m), i: idx })
-			} else {
-				const pts = res.values
-					.map((v, i) => ({ vx: scalePos(xs, rows[i][x]), vy: ys(v) }))
-					.filter((p) => Number.isFinite(p.vx) && Number.isFinite(p.vy))
-				const gen = d3line<{ vx: number; vy: number }>()
-					.x((p) => p.vx)
-					.y((p) => p.vy)
-				const d = gen(pts)
-				if (d) out.push({ d, type: typeOf(m), i: idx })
-			}
-		})
-		return out
+		if (!ctx) return []
+		return methods.map((m, i) => trendPath(ctx, m, i)).filter((p) => p !== null)
 	})
 </script>
 

package/dist/lib/brewing/polar.d.ts

@@ -190,23 +190,34 @@ export function resolveRadiusTransform(weights: number[], requested?: "linear" |
  * polygon" principle `resolveAxes` already applies to axis membership. The geom is expected to
  * break the polygon's outline at a `null` vertex instead of drawing a line through it.
  *
+ * The geometry arguments travel as one bag rather than six positionals, matching `ringsFor`'s
+ * `(axes, { R, rings, domains, transform })` shape. At the call site that is the difference
+ * between `verticesFor(data, axes, angles, domains, 100, 'linear', channels)` — where the reader
+ * has to count commas to learn what `100` and `'linear'` mean — and naming each one.
+ *
  * @param {Object[]} data
  * @param {ResolvedAxis[]} axes - from `resolveAxes`; vertex order follows this array
- * @param {number[]} angles - from `anglesFor(axes.map(a => a.weight))`, aligned with `axes`
- * @param {[number, number][]} domains - from `domainsFor`, aligned with `axes`
- * @param {number} R - outer radius in pixels, forwarded to `radiusFor`
- * @param {'linear'|'sqrt'} transform - forwarded to `radiusFor`
  * @param {{ x: string, y: string, color?: string }} channels - `x` names the axis field, `y` the
  *   value field, `color` the series field — mirroring `fill ?? color`'s role as the series
  *   channel in every other geom. Omitting it entirely means one implicit series.
+ * @param {Object} geometry
+ * @param {number[]} geometry.angles - from `anglesFor(axes.map(a => a.weight))`, aligned with `axes`
+ * @param {[number, number][]} geometry.domains - from `domainsFor`, aligned with `axes`
+ * @param {number} geometry.R - outer radius in pixels, forwarded to `radiusFor`
+ * @param {'linear'|'sqrt'} geometry.transform - forwarded to `radiusFor`
  * @returns {Map<unknown, (Vertex|null)[]>} one entry per distinct series value (or the single key
  *   `undefined` when `channels.color` is omitted), each holding one vertex — or `null` for a
  *   gap — per axis, in `axes` order
  */
-export function verticesFor(data: Object[], axes: ResolvedAxis[], angles: number[], domains: [number, number][], R: number, transform: "linear" | "sqrt", channels: {
+export function verticesFor(data: Object[], axes: ResolvedAxis[], channels: {
     x: string;
     y: string;
     color?: string;
+}, { angles, domains, R, transform }: {
+    angles: number[];
+    domains: [number, number][];
+    R: number;
+    transform: "linear" | "sqrt";
 }): Map<unknown, (Vertex | null)[]>;
 /**
  * Concentric grid rings for a radar chart — one shared set of circles, evenly spaced in

package/dist/lib/brewing/polar.js

@@ -79,38 +79,50 @@ function normaliseAxis(entry) {
  */
 export function resolveAxes(axes, data, axisField) {
 	if (!axes) {
-		const seen = new Set()
-		for (const row of data) {
-			const key = row?.[axisField]
-			if (key !== undefined && !seen.has(key)) seen.add(key)
-		}
-		// eslint-disable-next-line no-console
-		console.warn(
-			'[Radar] No `axes` prop given — falling back to first-appearance order in the data. ' +
-				'Radar shape is order-sensitive (adjacent axes read as related), so pass an explicit ' +
-				'`axes` array to make the order an analytical choice rather than an accident of row order.'
-		)
-		return [...seen].map(normaliseAxis)
+		warnInferredAxisOrder()
+		return axisKeysInData(data, axisField).map(normaliseAxis)
 	}
 
 	const resolved = axes.map(normaliseAxis)
-
 	const declaredKeys = new Set(resolved.map((a) => a.key))
-	const dataKeys = new Set()
+	warnDroppedAxes(axisKeysInData(data, axisField).filter((key) => !declaredKeys.has(key)))
+	return resolved
+}
+
+/**
+ * Distinct axis keys present in the data, in first-appearance order. Shared by
+ * both branches of `resolveAxes`, which previously walked the rows twice with
+ * near-identical loops.
+ * @param {Object[]} data
+ * @param {string} axisField
+ * @returns {unknown[]}
+ */
+function axisKeysInData(data, axisField) {
+	const seen = new Set()
 	for (const row of data) {
 		const key = row?.[axisField]
-		if (key !== undefined) dataKeys.add(key)
-	}
-	const dropped = [...dataKeys].filter((key) => !declaredKeys.has(key))
-	if (dropped.length > 0) {
-		// eslint-disable-next-line no-console
-		console.warn(
-			`[Radar] Data axis(es) not named in \`axes\` were dropped: ${dropped.join(', ')}. ` +
-				'Add them to `axes` if they belong on the chart.'
-		)
+		if (key !== undefined) seen.add(key)
 	}
+	return [...seen]
+}
 
-	return resolved
+function warnInferredAxisOrder() {
+	// eslint-disable-next-line no-console
+	console.warn(
+		'[Radar] No `axes` prop given — falling back to first-appearance order in the data. ' +
+			'Radar shape is order-sensitive (adjacent axes read as related), so pass an explicit ' +
+			'`axes` array to make the order an analytical choice rather than an accident of row order.'
+	)
+}
+
+/** @param {unknown[]} dropped */
+function warnDroppedAxes(dropped) {
+	if (dropped.length === 0) return
+	// eslint-disable-next-line no-console
+	console.warn(
+		`[Radar] Data axis(es) not named in \`axes\` were dropped: ${dropped.join(', ')}. ` +
+			'Add them to `axes` if they belong on the chart.'
+	)
 }
 
 /**
@@ -180,27 +192,42 @@ export function anglesFor(weights) {
  * @returns {[number, number][]} one domain per axis, positionally aligned with `axes`
  */
 export function domainsFor(axes, data, channels, opts = {}) {
-	const { x: axisField, y: valueField } = channels
-	const sharedDomain = opts.sharedDomain ?? false
+	const valuesByKey = finiteValuesByAxis(axes, data, channels)
+	const shared = opts.sharedDomain ? inferDomain([...valuesByKey.values()].flat()) : null
+	return axes.map((axis) => axis.domain ?? shared ?? inferDomain(valuesByKey.get(axis.key)))
+}
 
-	const valuesByKey = new Map(axes.map((axis) => [axis.key, []]))
+/**
+ * Finite values bucketed per axis key. Rows naming an axis that isn't declared
+ * are skipped — `resolveAxes` has already warned about them.
+ * @param {ResolvedAxis[]} axes
+ * @param {Object[]} data
+ * @param {{ x: string, y: string }} channels
+ * @returns {Map<unknown, number[]>}
+ */
+function finiteValuesByAxis(axes, data, { x: axisField, y: valueField }) {
+	const byKey = new Map(axes.map((axis) => [axis.key, []]))
 	for (const row of data) {
-		const values = valuesByKey.get(row?.[axisField])
+		const values = byKey.get(row?.[axisField])
 		if (!values) continue
 		const value = row?.[valueField]
 		if (Number.isFinite(value)) values.push(value)
 	}
+	return byKey
+}
 
-	const infer = (values) => {
-		if (values.length === 0) return [0, 0]
-		const min = Math.min(...values)
-		const max = Math.max(...values)
-		return min < 0 ? [min, max] : [0, max]
-	}
-
-	const shared = sharedDomain ? infer([...valuesByKey.values()].flat()) : null
-
-	return axes.map((axis) => axis.domain ?? shared ?? infer(valuesByKey.get(axis.key)))
+/**
+ * Domain covering `values`, anchored at 0 unless the data goes negative. An
+ * axis with no values gets `[0, 0]` — enough to render an empty spoke without
+ * the radius math blowing up (see `radiusFor`).
+ * @param {number[]} values
+ * @returns {[number, number]}
+ */
+function inferDomain(values) {
+	if (values.length === 0) return [0, 0]
+	const min = Math.min(...values)
+	const max = Math.max(...values)
+	return min < 0 ? [min, max] : [0, max]
 }
 
 /**
@@ -335,52 +362,36 @@ export function resolveRadiusTransform(weights, requested = 'auto') {
  * polygon" principle `resolveAxes` already applies to axis membership. The geom is expected to
  * break the polygon's outline at a `null` vertex instead of drawing a line through it.
  *
+ * The geometry arguments travel as one bag rather than six positionals, matching `ringsFor`'s
+ * `(axes, { R, rings, domains, transform })` shape. At the call site that is the difference
+ * between `verticesFor(data, axes, angles, domains, 100, 'linear', channels)` — where the reader
+ * has to count commas to learn what `100` and `'linear'` mean — and naming each one.
+ *
  * @param {Object[]} data
  * @param {ResolvedAxis[]} axes - from `resolveAxes`; vertex order follows this array
- * @param {number[]} angles - from `anglesFor(axes.map(a => a.weight))`, aligned with `axes`
- * @param {[number, number][]} domains - from `domainsFor`, aligned with `axes`
- * @param {number} R - outer radius in pixels, forwarded to `radiusFor`
- * @param {'linear'|'sqrt'} transform - forwarded to `radiusFor`
  * @param {{ x: string, y: string, color?: string }} channels - `x` names the axis field, `y` the
  *   value field, `color` the series field — mirroring `fill ?? color`'s role as the series
  *   channel in every other geom. Omitting it entirely means one implicit series.
+ * @param {Object} geometry
+ * @param {number[]} geometry.angles - from `anglesFor(axes.map(a => a.weight))`, aligned with `axes`
+ * @param {[number, number][]} geometry.domains - from `domainsFor`, aligned with `axes`
+ * @param {number} geometry.R - outer radius in pixels, forwarded to `radiusFor`
+ * @param {'linear'|'sqrt'} geometry.transform - forwarded to `radiusFor`
  * @returns {Map<unknown, (Vertex|null)[]>} one entry per distinct series value (or the single key
  *   `undefined` when `channels.color` is omitted), each holding one vertex — or `null` for a
  *   gap — per axis, in `axes` order
  */
-export function verticesFor(data, axes, angles, domains, R, transform, channels) {
-	const { x: axisField, y: valueField, color: seriesField } = channels
-
-	const cells = new Map()
-	for (const row of data) {
-		const seriesKey = seriesField !== undefined ? row?.[seriesField] : undefined
-		const axisKey = row?.[axisField]
-		if (!cells.has(seriesKey)) cells.set(seriesKey, new Map())
-		const bySeries = cells.get(seriesKey)
-		if (!bySeries.has(axisKey)) bySeries.set(axisKey, [])
-		bySeries.get(axisKey).push(row)
-	}
+export function verticesFor(data, axes, channels, { angles, domains, R, transform }) {
+	const { y: valueField } = channels
+	const cells = cellsBySeriesAndAxis(data, channels)
 
 	const result = new Map()
 	for (const [seriesKey, bySeries] of cells) {
 		const vertices = axes.map((axis, i) => {
 			const rows = bySeries.get(axis.key)
 			if (!rows) return null
-
-			if (rows.length > 1) {
-				// eslint-disable-next-line no-console
-				console.warn(
-					`[Radar] Duplicate (series, axis) cell — axis "${axis.key}"` +
-						`${seriesKey !== undefined ? `, series "${seriesKey}"` : ''} has ${rows.length} rows; ` +
-						'averaging their values. A repeated (series, axis) pair is almost always a data bug, ' +
-						'since axis is a small fixed enum rather than a repeated-measurement field.'
-				)
-			}
-
-			const values = rows.map((row) => row[valueField]).filter(Number.isFinite)
-			if (values.length === 0) return null
-
-			const value = values.reduce((a, b) => a + b, 0) / values.length
+			const value = cellValue(rows, { axisKey: axis.key, seriesKey, valueField })
+			if (value === null) return null
 			return {
 				axisKey: axis.key,
 				value,
@@ -395,6 +406,56 @@ export function verticesFor(data, axes, angles, domains, R, transform, channels)
 	return result
 }
 
+/**
+ * Group rows two levels deep, series → axis → rows, because a radar cell is
+ * identified by the `(series, axis)` pair rather than by either alone.
+ * @param {Object[]} data
+ * @param {{ x: string, color?: string }} channels
+ * @returns {Map<unknown, Map<unknown, Object[]>>}
+ */
+function cellsBySeriesAndAxis(data, { x: axisField, color: seriesField }) {
+	const cells = new Map()
+	for (const row of data) {
+		const seriesKey = seriesField !== undefined ? row?.[seriesField] : undefined
+		const axisKey = row?.[axisField]
+		if (!cells.has(seriesKey)) cells.set(seriesKey, new Map())
+		const bySeries = cells.get(seriesKey)
+		if (!bySeries.has(axisKey)) bySeries.set(axisKey, [])
+		bySeries.get(axisKey).push(row)
+	}
+	return cells
+}
+
+/**
+ * The single value a `(series, axis)` cell contributes: the mean of its finite
+ * values, or `null` when it has none. See this module's `verticesFor` doc for
+ * why a repeated pair is averaged AND warned about rather than silently picked.
+ * @param {Object[]} rows
+ * @param {{ axisKey: unknown, seriesKey: unknown, valueField: string }} cell
+ * @returns {number|null}
+ */
+function cellValue(rows, { axisKey, seriesKey, valueField }) {
+	if (rows.length > 1) warnDuplicateCell(rows.length, axisKey, seriesKey)
+	const values = rows.map((row) => row[valueField]).filter(Number.isFinite)
+	if (values.length === 0) return null
+	return values.reduce((a, b) => a + b, 0) / values.length
+}
+
+/**
+ * @param {number} count
+ * @param {unknown} axisKey
+ * @param {unknown} seriesKey
+ */
+function warnDuplicateCell(count, axisKey, seriesKey) {
+	// eslint-disable-next-line no-console
+	console.warn(
+		`[Radar] Duplicate (series, axis) cell — axis "${axisKey}"` +
+			`${seriesKey !== undefined ? `, series "${seriesKey}"` : ''} has ${count} rows; ` +
+			'averaging their values. A repeated (series, axis) pair is almost always a data bug, ' +
+			'since axis is a small fixed enum rather than a repeated-measurement field.'
+	)
+}
+
 /**
  * @typedef {Object} Ring
  * @property {number} radius - pixels from centre
@@ -576,7 +637,7 @@ export function buildRadarLayout(data, channels, opts = {}) {
 	const angles = anglesFor(weights)
 	const domains = domainsFor(axes, data, channels, { sharedDomain: opts.sharedDomain })
 	const transform = resolveRadiusTransform(weights, opts.radiusScale)
-	const series = verticesFor(data, axes, angles, domains, R, transform, channels)
+	const series = verticesFor(data, axes, channels, { angles, domains, R, transform })
 	const rings = ringsFor(axes, { R, rings: opts.rings, domains, transform })
 	const zeroRings = zeroRingFor(axes, domains, R, transform)
 

package/dist/lib/highlight.js

@@ -1,43 +1,94 @@
 /**
- * Resolve a highlight selector to zero or more row indices.
+ * Highlight-selector resolution.
+ *
+ * One small resolver per selector kind, plus a dispatcher. The kinds share
+ * nothing but their signature, so keeping them separate means each can be read
+ * and tested on its own instead of as one branch of a 24-complexity chain.
+ */
+
+/**
+ * Indices where a predicate selector matches.
  * @param {Array<Record<string, unknown>>} rows
- * @param {'first'|'last'|'min'|'max'|number|((row:any,i:number)=>boolean)} selector
- * @param {{ y?: string }} [opts]
+ * @param {(row: any, i: number) => boolean} predicate
  * @returns {number[]}
  */
-export function resolveHighlight(rows, selector, opts = {}) {
-	if (!Array.isArray(rows) || rows.length === 0 || selector === null || selector === undefined)
-		return []
-	const { y } = opts
+function byPredicate(rows, predicate) {
+	const out = []
+	for (let i = 0; i < rows.length; i++) if (predicate(rows[i], i)) out.push(i)
+	return out
+}
 
-	if (typeof selector === 'function') {
-		const out = []
-		for (let i = 0; i < rows.length; i++) if (selector(rows[i], i)) out.push(i)
-		return out
-	}
+/**
+ * A single index. Negative values count back from the end (`-1` is the last
+ * row); anything out of range resolves to nothing.
+ * @param {Array<Record<string, unknown>>} rows
+ * @param {number} index
+ * @returns {number[]}
+ */
+function byIndex(rows, index) {
+	const i = index < 0 ? rows.length + index : index
+	return i >= 0 && i < rows.length ? [i] : []
+}
 
-	if (typeof selector === 'number') {
-		const i = selector < 0 ? rows.length + selector : selector
-		return i >= 0 && i < rows.length ? [i] : []
-	}
+/**
+ * The index of the row whose numeric `y` is smallest (`min`) or largest (`max`).
+ *
+ * Non-numeric values are dropped rather than compared — `NaN` loses every
+ * comparison, so leaving them in would make the result depend on iteration
+ * order. Ties keep the earliest row. Candidates are collected before reducing
+ * so an all-`Infinity` column still resolves to its first row, which a
+ * strict-improvement scan seeded with `Infinity` would reject.
+ *
+ * @param {Array<Record<string, unknown>>} rows
+ * @param {string | undefined} y
+ * @param {'min'|'max'} kind
+ * @returns {number[]}
+ */
+function byExtreme(rows, y, kind) {
+	if (!y) return []
+	// Searching for the smallest `sign * value` finds the max when sign is -1,
+	// which collapses two mirror-image scans into one.
+	const sign = kind === 'min' ? 1 : -1
+	const candidates = rows
+		.map((row, i) => ({ i, value: sign * Number(row[y]) }))
+		.filter(({ value }) => !Number.isNaN(value))
+	if (candidates.length === 0) return []
+	return [candidates.reduce((best, c) => (c.value < best.value ? c : best)).i]
+}
 
-	if (selector === 'first') return [0]
-	if (selector === 'last') return [rows.length - 1]
+/**
+ * Named selectors, all sharing one signature so the dispatcher can call any of
+ * them uniformly. `rows` is guaranteed non-empty by the time these run.
+ * @type {Record<string, (rows: Array<Record<string, unknown>>, y?: string) => number[]>}
+ */
+const NAMED = {
+	first: () => [0],
+	last: (rows) => [rows.length - 1],
+	min: (rows, y) => byExtreme(rows, y, 'min'),
+	max: (rows, y) => byExtreme(rows, y, 'max')
+}
 
-	if (selector === 'min' || selector === 'max') {
-		if (!y) return []
-		let best = -1
-		let bestVal = null
-		for (let i = 0; i < rows.length; i++) {
-			const v = Number(rows[i][y])
-			if (Number.isNaN(v)) continue
-			if (bestVal === null || (selector === 'min' ? v < bestVal : v > bestVal)) {
-				bestVal = v
-				best = i
-			}
-		}
-		return best === -1 ? [] : [best]
-	}
+/**
+ * True when the inputs cannot resolve to any row, whatever the selector means.
+ * @param {unknown} rows
+ * @param {unknown} selector
+ */
+const isUnresolvable = (rows, selector) =>
+	!Array.isArray(rows) || rows.length === 0 || selector === null || selector === undefined
 
-	return []
+/**
+ * Resolve a highlight selector to zero or more row indices.
+ * @param {Array<Record<string, unknown>>} rows
+ * @param {'first'|'last'|'min'|'max'|number|((row:any,i:number)=>boolean)} selector
+ * @param {{ y?: string }} [opts]
+ * @returns {number[]}
+ */
+export function resolveHighlight(rows, selector, opts = {}) {
+	if (isUnresolvable(rows, selector)) return []
+	if (typeof selector === 'function') return byPredicate(rows, selector)
+	if (typeof selector === 'number') return byIndex(rows, selector)
+	// hasOwn, not a bare lookup: `NAMED['constructor']` would otherwise resolve to
+	// Object's constructor and get called. Same guard as PATTERNS in SparkState.
+	const named = Object.hasOwn(NAMED, selector) ? NAMED[selector] : null
+	return named ? named(rows, opts.y) : []
 }

package/dist/lib/select.d.ts

@@ -1,16 +1,30 @@
 /**
  * Assemble the SelectDetail handed to a chart's onselect callback.
- * @param {Record<string, unknown>} datum
- * @param {number} index  index within the geom's rendered data
- * @param {{ x?: string, y?: string }} channels
- * @param {'line'|'point'|'area'|'bar'|'radar'} geom
- * @param {unknown} series  color/group value, or undefined
- * @param {MouseEvent|KeyboardEvent} event
+ *
+ * Takes one named bag rather than six positionals: the tail of the old
+ * signature read `…, { x, y }, 'line', seg?.key, event)` at every call site,
+ * where nothing but the argument order told you which of the trailing values
+ * was the geom and which was the series.
+ *
+ * @param {Object} args
+ * @param {Record<string, unknown>} args.datum
+ * @param {number} args.index  index within the geom's rendered data
+ * @param {{ x?: string, y?: string }} args.channels
+ * @param {'line'|'point'|'area'|'bar'|'radar'} args.geom
+ * @param {unknown} [args.series]  color/group value, or undefined
+ * @param {MouseEvent|KeyboardEvent} args.event
  */
-export function buildSelectDetail(datum: Record<string, unknown>, index: number, channels: {
-    x?: string;
-    y?: string;
-}, geom: "line" | "point" | "area" | "bar" | "radar", series: unknown, event: MouseEvent | KeyboardEvent): {
+export function buildSelectDetail({ datum, index, channels, geom, series, event }: {
+    datum: Record<string, unknown>;
+    index: number;
+    channels: {
+        x?: string;
+        y?: string;
+    };
+    geom: "line" | "point" | "area" | "bar" | "radar";
+    series?: unknown;
+    event: MouseEvent | KeyboardEvent;
+}): {
     datum: Record<string, unknown>;
     index: number;
     series: {} | undefined;

package/dist/lib/select.js

@@ -1,13 +1,20 @@
 /**
  * Assemble the SelectDetail handed to a chart's onselect callback.
- * @param {Record<string, unknown>} datum
- * @param {number} index  index within the geom's rendered data
- * @param {{ x?: string, y?: string }} channels
- * @param {'line'|'point'|'area'|'bar'|'radar'} geom
- * @param {unknown} series  color/group value, or undefined
- * @param {MouseEvent|KeyboardEvent} event
+ *
+ * Takes one named bag rather than six positionals: the tail of the old
+ * signature read `…, { x, y }, 'line', seg?.key, event)` at every call site,
+ * where nothing but the argument order told you which of the trailing values
+ * was the geom and which was the series.
+ *
+ * @param {Object} args
+ * @param {Record<string, unknown>} args.datum
+ * @param {number} args.index  index within the geom's rendered data
+ * @param {{ x?: string, y?: string }} args.channels
+ * @param {'line'|'point'|'area'|'bar'|'radar'} args.geom
+ * @param {unknown} [args.series]  color/group value, or undefined
+ * @param {MouseEvent|KeyboardEvent} args.event
  */
-export function buildSelectDetail(datum, index, channels, geom, series, event) {
+export function buildSelectDetail({ datum, index, channels, geom, series, event }) {
 	const { x, y } = channels
 	return {
 		datum,

package/dist/lib/trend.js

@@ -58,14 +58,63 @@ export function expRegression(xs, ys) {
 	return { a: Math.exp(reg.b), b: reg.m }
 }
 
+/** `mean` is an accepted alias for `avg`. */
+const canonicalType = (type) => (type === 'mean' ? 'avg' : type)
+
+/** Accept a number, a bare type name, or a full config object; produce a config or null. */
 function normalize(method) {
 	if (typeof method === 'number') return { type: 'value', value: method }
-	if (typeof method === 'string') return { type: method === 'mean' ? 'avg' : method }
+	if (typeof method === 'string') return { type: canonicalType(method) }
 	if (method && typeof method === 'object' && method.type)
-		return { ...method, type: method.type === 'mean' ? 'avg' : method.type }
+		return { ...method, type: canonicalType(method.type) }
 	return null
 }
 
+/**
+ * Numeric series for the two channels. A non-finite x falls back to the row
+ * index, which is what makes trends work on a categorical/band axis.
+ * @param {Array<Record<string, unknown>>} rows
+ * @param {{x?: string, y?: string}} channels
+ */
+function toSeries(rows, { x, y }) {
+	return {
+		ys: rows.map((r) => Number(r[y])),
+		xs: rows.map((r, i) => {
+			const v = Number(r[x])
+			return Number.isFinite(v) ? v : i
+		})
+	}
+}
+
+/**
+ * One builder per trend type, replacing a nine-case switch. Each takes the
+ * prepared series plus the normalized config and returns a trend or null, so a
+ * new trend type is a new entry rather than another branch.
+ * @type {Record<string, (ctx: {xs: number[], ys: number[], cfg: Record<string, any>}) => object | null>}
+ */
+const BUILDERS = {
+	avg: ({ ys }) => ({ kind: 'constant', value: mean(ys) }),
+	median: ({ ys }) => ({ kind: 'constant', value: median(ys) }),
+	min: ({ ys }) => ({ kind: 'constant', value: Math.min(...ys) }),
+	max: ({ ys }) => ({ kind: 'constant', value: Math.max(...ys) }),
+	value: ({ cfg }) =>
+		typeof cfg.value === 'number' ? { kind: 'constant', value: cfg.value } : null,
+	linear: ({ xs, ys }) => {
+		const reg = linearRegression(xs, ys)
+		return reg ? { kind: 'series', values: xs.map((v) => reg.m * v + reg.b) } : null
+	},
+	ma: ({ ys, cfg }) =>
+		cfg.window ? { kind: 'series', values: movingAverage(ys, cfg.window) } : null,
+	ema: ({ ys, cfg }) => ({
+		kind: 'series',
+		values: ema(ys, { span: cfg.span, alpha: cfg.alpha })
+	}),
+	exp: ({ xs, ys }) => {
+		const reg = expRegression(xs, ys)
+		return reg ? { kind: 'series', values: xs.map((v) => reg.a * Math.exp(reg.b * v)) } : null
+	}
+}
+
 /**
  * Compute a trend for `rows` on channels {x, y}.
  * @returns {{kind:'constant', value:number} | {kind:'series', values:number[]} | null}
@@ -73,41 +122,8 @@ function normalize(method) {
 export function computeTrend(rows, channels, method) {
 	const cfg = normalize(method)
 	if (!cfg || !Array.isArray(rows) || rows.length === 0) return null
-	const { x, y } = channels
-	const ys = rows.map((r) => Number(r[y]))
-	const xs = rows.map((r, i) => {
-		const v = Number(r[x])
-		return Number.isFinite(v) ? v : i
-	})
-
-	switch (cfg.type) {
-		case 'avg':
-			return { kind: 'constant', value: mean(ys) }
-		case 'median':
-			return { kind: 'constant', value: median(ys) }
-		case 'min':
-			return { kind: 'constant', value: Math.min(...ys) }
-		case 'max':
-			return { kind: 'constant', value: Math.max(...ys) }
-		case 'value':
-			return typeof cfg.value === 'number' ? { kind: 'constant', value: cfg.value } : null
-		case 'linear': {
-			const reg = linearRegression(xs, ys)
-			if (!reg) return null
-			return { kind: 'series', values: xs.map((v) => reg.m * v + reg.b) }
-		}
-		case 'ma': {
-			if (!cfg.window) return null
-			return { kind: 'series', values: movingAverage(ys, cfg.window) }
-		}
-		case 'ema':
-			return { kind: 'series', values: ema(ys, { span: cfg.span, alpha: cfg.alpha }) }
-		case 'exp': {
-			const reg = expRegression(xs, ys)
-			if (!reg) return null
-			return { kind: 'series', values: xs.map((v) => reg.a * Math.exp(reg.b * v)) }
-		}
-		default:
-			return null
-	}
+	// hasOwn, not a bare lookup: an unknown type must fall through to null, and a
+	// bare `BUILDERS[cfg.type]` would resolve inherited keys like 'constructor'.
+	if (!Object.hasOwn(BUILDERS, cfg.type)) return null
+	return BUILDERS[cfg.type]({ ...toSeries(rows, channels), cfg })
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rokkit/chart",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "type": "module",
   "description": "Data-driven chart components",
   "repository": {