@rokkit/chart 1.3.8 → 1.3.9

package/dist/geoms/lib/aesthetics.js

@@ -0,0 +1,45 @@
+// Shared aesthetic resolution for all geoms. Done ONCE here so every geom's build
+// function inherits the same ggplot-aligned fill/color and alpha rules.
+// See docs/backlog/2026-08-17-chart-aesthetics-unification.md §2, §3, §11.
+
+const GRAY = { fill: '#888', stroke: '#888' }
+
+/**
+ * Resolve a mark's interior (fill) and outline (stroke) from the `fill` and `color`
+ * channels through the shared categorical `colors` palette (Map<value, {fill, stroke}>).
+ *
+ * ggplot fallback:
+ *  - color-only → fill AND stroke from the color value's entry (backward compatible)
+ *  - fill-only  → fill AND stroke from the fill value's entry
+ *  - both       → interior from the fill value, outline from the color value
+ *  - neither    → the first palette entry (single-series)
+ *
+ * @param {Record<string, unknown>} row
+ * @param {{ fill?: string, color?: string }} channels
+ * @param {Map<unknown, { fill: string, stroke: string }>} colors
+ * @returns {{ fill: string, stroke: string }}
+ */
+export function resolveFillStroke(row, channels, colors) {
+	const { fill, color } = channels ?? {}
+	const first = colors?.values?.().next?.().value ?? GRAY
+	const fillEntry = fill ? (colors?.get(row?.[fill]) ?? first) : null
+	const colorEntry = color ? (colors?.get(row?.[color]) ?? first) : null
+	const base = fillEntry ?? colorEntry ?? first
+	return {
+		fill: (fillEntry ?? base).fill,
+		stroke: (colorEntry ?? base).stroke
+	}
+}
+
+/**
+ * Resolve a geom's mark opacity: an explicit fixed `alpha`, else the per-geom preset
+ * default, else fully opaque.
+ * @param {number|undefined} alpha
+ * @param {string} type - geom type key into preset.opacity
+ * @param {{ opacity?: Record<string, number> }} [preset]
+ * @returns {number}
+ */
+export function resolveAlpha(alpha, type, preset) {
+	if (typeof alpha === 'number') return alpha
+	return preset?.opacity?.[type] ?? 1
+}

package/dist/geoms/lib/areas.d.ts

@@ -49,7 +49,7 @@ export function buildStackedAreas(data: Object[], channels: {
 }>, curve?: "linear" | "smooth" | "step", patterns?: Map<unknown, string>, place?: (x: any, y: any) => {
     x: any;
     y: any;
-}): {
+}, normalize?: boolean): {
     d: string;
     fill: string;
     stroke: string;

package/dist/geoms/lib/areas.js

@@ -1,4 +1,4 @@
-import { area, stack, curveCatmullRom, curveStep } from 'd3-shape'
+import { area, stack, stackOffsetExpand, curveCatmullRom, curveStep } from 'd3-shape'
 import { toPatternId } from '../../lib/brewing/patterns.js'
 
 /**
@@ -92,7 +92,7 @@ export function buildAreas(data, channels, xScale, yScale, colors, curve, patter
  * @param {Map<unknown, string>} [patterns]
  * @returns {{ d: string, fill: string, stroke: string, key: unknown, patternId: string|null }[]}
  */
-export function buildStackedAreas(data, channels, xScale, yScale, colors, curve, patterns, place = (x, y) => ({ x, y })) {
+export function buildStackedAreas(data, channels, xScale, yScale, colors, curve, patterns, place = (x, y) => ({ x, y }), normalize = false) {
 	const { x: xf, y: yf, color: cf, pattern: pf } = channels
 	if (!cf) return buildAreas(data, channels, xScale, yScale, colors, curve, patterns)
 
@@ -132,6 +132,8 @@ export function buildStackedAreas(data, channels, xScale, yScale, colors, curve,
 	}
 
 	const stackGen = stack().keys(colorCategories)
+	// position='fill' → normalize each x column to [0,1] (100% stacked area).
+	if (normalize) stackGen.offset(stackOffsetExpand)
 	const layers = stackGen(wide)
 
 	const orderedPatternKeys = pf && pf !== cf ? [...(patterns?.keys() ?? [])] : null

package/dist/geoms/lib/bars.d.ts

@@ -11,8 +11,8 @@
 export function buildBars(data: any, channels: any, xScale: any, yScale: any, colors: any, innerHeight: any, patterns: any, place?: (x: any, y: any) => {
     x: any;
     y: any;
-}, continuousCategory?: boolean): any;
+}, continuousCategory?: boolean, dodge?: boolean): any;
 export function buildStackedBars(data: any, channels: any, xScale: any, yScale: any, colors: any, innerHeight: any, patterns: any, place?: (x: any, y: any) => {
     x: any;
     y: any;
-}): any;
+}, normalize?: boolean): any;

package/dist/geoms/lib/bars.js

@@ -1,5 +1,5 @@
 import { scaleBand } from 'd3-scale'
-import { stack } from 'd3-shape'
+import { stack, stackOffsetExpand } from 'd3-shape'
 import { toPatternId } from '../../lib/brewing/patterns.js'
 import { isLiteralColor } from '../../lib/brewing/colors.js'
 
@@ -17,14 +17,15 @@ function ensureBandX(xScale, data, xField) {
 }
 
 /**
- * Returns the sub-band fields: distinct non-x fields among [color, pattern].
- * These are the fields that cause multiple bars within a single x-band.
+ * Returns the sub-band fields: distinct non-x fields among [group, color, pattern].
+ * These are the fields that cause multiple bars within a single x-band (dodge/grouping).
+ * `group` (the explicit grouping channel) takes precedence as the first sub-band.
  */
 function subBandFields(channels) {
-	const { x: xf, color: cf, pattern: pf } = channels
+	const { x: xf, group: gf, color: cf, pattern: pf } = channels
 	const seen = new Set()
 	const out = []
-	for (const f of [cf, pf]) {
+	for (const f of [gf, cf, pf]) {
 		if (f && f !== xf && !seen.has(f) && !isLiteralColor(f)) {
 			seen.add(f)
 			out.push(f)
@@ -52,11 +53,13 @@ export function buildBars(
 	innerHeight,
 	patterns,
 	place = (x, y) => ({ x, y }),
-	continuousCategory = false
+	continuousCategory = false,
+	dodge = true
 ) {
 	const { x: xf, y: yf, color: cf, pattern: pf } = channels
 
-	const subFields = continuousCategory ? [] : subBandFields(channels)
+	// No sub-banding for a continuous (race) axis or position='identity' (dodge=false → overlap).
+	const subFields = continuousCategory || !dodge ? [] : subBandFields(channels)
 	const getSubKey = (d) => subFields.map((f) => String(d[f])).join('::')
 
 	let positionOf
@@ -131,7 +134,7 @@ export function buildBars(
 	})
 }
 
-export function buildStackedBars(data, channels, xScale, yScale, colors, innerHeight, patterns, place = (x, y) => ({ x, y })) {
+export function buildStackedBars(data, channels, xScale, yScale, colors, innerHeight, patterns, place = (x, y) => ({ x, y }), normalize = false) {
 	const { x: xf, y: yf, color: cf, pattern: pf } = channels
 
 	const bandScale = ensureBandX(xScale, data, xf)
@@ -159,6 +162,8 @@ export function buildStackedBars(data, channels, xScale, yScale, colors, innerHe
 	})
 
 	const stackGen = stack().keys(stackCategories)
+	// position='fill' → normalize each x column to [0,1] (100% stacked).
+	if (normalize) stackGen.offset(stackOffsetExpand)
 	const layers = stackGen(wide)
 
 	const bars = []

package/dist/geoms/lib/marks/arc.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Build renderable pie/donut arcs. Slice interior + border come from `fill ?? color`
+ * through the shared palette (buildArcs already yields fill + a darker stroke). Adds the
+ * geom's fixed `alpha`.
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildArcMarks({ data, plot, channels, options, alpha, type }: {
+    data: any[];
+    plot: any;
+    channels: any;
+    options?: any;
+    alpha?: number;
+    type?: string;
+}): {
+    alpha: number;
+    d: string | null;
+    fill: string;
+    stroke: string;
+    key: unknown;
+    patternId: string | null;
+    pct: number;
+    centroid: [number, number];
+    data: Record<string, unknown>;
+}[];

package/dist/geoms/lib/marks/arc.js

@@ -0,0 +1,28 @@
+import { buildArcs } from '../../../lib/brewing/marks/arcs.js'
+import { resolveAlpha } from '../aesthetics.js'
+
+/**
+ * Build renderable pie/donut arcs. Slice interior + border come from `fill ?? color`
+ * through the shared palette (buildArcs already yields fill + a darker stroke). Adds the
+ * geom's fixed `alpha`.
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildArcMarks({ data, plot, channels, options = {}, alpha, type = 'arc' }) {
+	if (!data?.length) return []
+	const interiorField = channels.fill ?? channels.color
+	// Guard: skip until data catches up after a fill-field change — otherwise a stale row set
+	// (missing the new field) produces all-undefined keys and duplicate-key errors.
+	if (interiorField && data[0] && !(interiorField in data[0])) return []
+
+	const arcs = buildArcs(
+		data,
+		{ color: interiorField, y: channels.y, pattern: channels.pattern },
+		plot.colors,
+		plot.innerWidth,
+		plot.innerHeight,
+		{ innerRadius: options.innerRadius ?? 0 },
+		plot.patterns
+	)
+	const a = resolveAlpha(alpha, type, plot.chartPreset)
+	return arcs.map((arc) => ({ ...arc, alpha: a }))
+}

package/dist/geoms/lib/marks/area.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Build renderable area segments. Interior is grouped/filled by `fill ?? color`
+ * (ggplot geom_area's fill). A border stroke is drawn only when BOTH `fill` and `color`
+ * are set — so an old `color`-only area stays border-less (backward compatible); the
+ * border uses the interior group's darker stroke shade. Per-field border coloring
+ * (fill ≠ color, two legends) is the deferred dual-scale follow-up.
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildAreaMarks({ data, plot, channels, options, alpha, type }: {
+    data: any[];
+    plot: any;
+    channels: any;
+    options?: any;
+    alpha?: number;
+    type?: string;
+}): {
+    stroke: any;
+    alpha: number;
+    d: string;
+    fill: string;
+    key: unknown;
+    patternId: string | null;
+}[];

package/dist/geoms/lib/marks/area.js

@@ -0,0 +1,38 @@
+import { buildAreas, buildStackedAreas } from '../areas.js'
+import { resolveAlpha } from '../aesthetics.js'
+
+/**
+ * Build renderable area segments. Interior is grouped/filled by `fill ?? color`
+ * (ggplot geom_area's fill). A border stroke is drawn only when BOTH `fill` and `color`
+ * are set — so an old `color`-only area stays border-less (backward compatible); the
+ * border uses the interior group's darker stroke shade. Per-field border coloring
+ * (fill ≠ color, two legends) is the deferred dual-scale follow-up.
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildAreaMarks({ data, plot, channels, options = {}, alpha, type = 'area' }) {
+	const { xScale, yScale, colors, patterns } = plot
+	if (!data?.length || !xScale || !yScale || !channels.x || !channels.y) return []
+
+	const interiorField = channels.fill ?? channels.color
+	const hasBorder = Boolean(channels.fill && channels.color)
+	const place = plot.place.bind(plot)
+	const areaChannels = {
+		x: channels.x,
+		y: channels.y,
+		color: interiorField,
+		pattern: channels.pattern
+	}
+	// Areas don't dodge; position selects stack | fill (100%) | identity (overlap, default).
+	const position = options.position ?? (options.stack ? 'stack' : 'identity')
+	const stacked = position === 'stack' || position === 'fill'
+	const raw = stacked
+		? buildStackedAreas(data, areaChannels, xScale, yScale, colors, options.curve, patterns, place, position === 'fill')
+		: buildAreas(data, areaChannels, xScale, yScale, colors, options.curve, patterns, place)
+
+	const a = resolveAlpha(alpha, type, plot.chartPreset)
+	return raw.map((seg) => ({
+		...seg,
+		stroke: hasBorder ? (colors.get(seg.key)?.stroke ?? 'none') : 'none',
+		alpha: a
+	}))
+}

package/dist/geoms/lib/marks/bar.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Build renderable bar marks. Interior is grouped/filled by `fill ?? color`; the `group`
+ * channel (default `fill ?? color`) drives the sub-series partitioned by `position`:
+ *  - stack: cumulative segments      - dodge: side-by-side sub-bands (default)
+ *  - fill:  100% (normalized) stack  - identity: overlapping full-width bars
+ * `options.stack: true` maps to position 'stack' (back-compat). Adds the geom's fixed `alpha`.
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildBarMarks({ data, plot, channels, options, alpha, type }: {
+    data: any[];
+    plot: any;
+    channels: any;
+    options?: any;
+    alpha?: number;
+    type?: string;
+}): any;

package/dist/geoms/lib/marks/bar.js

@@ -0,0 +1,43 @@
+import { buildBars, buildStackedBars } from '../bars.js'
+import { resolveAlpha } from '../aesthetics.js'
+
+/**
+ * Build renderable bar marks. Interior is grouped/filled by `fill ?? color`; the `group`
+ * channel (default `fill ?? color`) drives the sub-series partitioned by `position`:
+ *  - stack: cumulative segments      - dodge: side-by-side sub-bands (default)
+ *  - fill:  100% (normalized) stack  - identity: overlapping full-width bars
+ * `options.stack: true` maps to position 'stack' (back-compat). Adds the geom's fixed `alpha`.
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildBarMarks({ data, plot, channels, options = {}, alpha, type = 'bar' }) {
+	const { xScale, yScale, colors, patterns } = plot
+	if (!data?.length || !xScale || !yScale) return []
+
+	const interiorField = channels.fill ?? channels.color
+	const groupField = channels.group ?? channels.fill ?? channels.color
+	const barChannels = {
+		x: channels.x,
+		y: channels.y,
+		color: interiorField,
+		pattern: channels.pattern,
+		group: groupField
+	}
+	const place = plot.place.bind(plot)
+	const ih = plot.innerHeight
+	const position = options.position ?? (options.stack ? 'stack' : 'dodge')
+
+	let raw
+	if (position === 'stack') {
+		raw = buildStackedBars(data, barChannels, xScale, yScale, colors, ih, patterns, place, false)
+	} else if (position === 'fill') {
+		raw = buildStackedBars(data, barChannels, xScale, yScale, colors, ih, patterns, place, true)
+	} else if (position === 'identity') {
+		raw = buildBars(data, barChannels, xScale, yScale, colors, ih, patterns, place, plot.continuousCategory, false)
+	} else {
+		// dodge (default): side-by-side sub-bands
+		raw = buildBars(data, barChannels, xScale, yScale, colors, ih, patterns, place, plot.continuousCategory, true)
+	}
+
+	const a = resolveAlpha(alpha, type, plot.chartPreset)
+	return raw.map((bar) => ({ ...bar, alpha: a }))
+}

package/dist/geoms/lib/marks/box.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Build renderable box marks. Body fill + outline (whiskers/median/caps) come from the
+ * `fill` channel (defaulting to `x`); an explicit `color` channel overrides the outline
+ * stroke (interior stays from `fill`). Adds the geom's fixed `alpha`.
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildBoxMarks({ data, plot, channels, options, alpha, type }: {
+    data: any[];
+    plot: any;
+    channels: any;
+    options?: any;
+    alpha?: number;
+    type?: string;
+}): any[];

package/dist/geoms/lib/marks/box.js

@@ -0,0 +1,30 @@
+import { buildBoxes } from '../../../lib/brewing/marks/boxes.js'
+import { resolveAlpha } from '../aesthetics.js'
+
+/**
+ * Build renderable box marks. Body fill + outline (whiskers/median/caps) come from the
+ * `fill` channel (defaulting to `x`); an explicit `color` channel overrides the outline
+ * stroke (interior stays from `fill`). Adds the geom's fixed `alpha`.
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildBoxMarks({ data, plot, channels, options = {}, alpha, type = 'box' }) {
+	const { xScale, yScale, colors } = plot
+	if (!data?.length || !xScale || !yScale) return []
+
+	const fillField = channels.fill ?? channels.x
+	const boxes = buildBoxes(
+		data,
+		{ x: channels.x, fill: fillField, pattern: channels.pattern },
+		xScale,
+		yScale,
+		colors,
+		{ side: options.side, width: options.width, patterns: plot.patterns }
+	)
+	const a = resolveAlpha(alpha, type, plot.chartPreset)
+	const colorField = channels.color
+	return boxes.map((box) => ({
+		...box,
+		stroke: colorField ? (colors.get(box.data[colorField])?.stroke ?? box.stroke) : box.stroke,
+		alpha: a
+	}))
+}

package/dist/geoms/lib/marks/candlestick.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Build renderable candlesticks. Body + wick color is semantic (up/down from options), not
+ * the shared palette. Adds fixed `alpha`. Places (band, value) corners through place() so the
+ * candle transposes under orientation flip.
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildCandleMarks({ data, plot, channels, options, alpha, type }: {
+    data: any[];
+    plot: any;
+    channels: any;
+    options?: any;
+    alpha?: number;
+    type?: string;
+}): {
+    key: string;
+    bodyX: number;
+    bodyY: number;
+    bodyWidth: number;
+    bodyHeight: number;
+    fill: any;
+    alpha: number;
+    wickX1: any;
+    wickY1: any;
+    wickX2: any;
+    wickY2: any;
+    data: any;
+}[];

package/dist/geoms/lib/marks/candlestick.js

@@ -0,0 +1,52 @@
+import { resolveAlpha } from '../aesthetics.js'
+
+/**
+ * Build renderable candlesticks. Body + wick color is semantic (up/down from options), not
+ * the shared palette. Adds fixed `alpha`. Places (band, value) corners through place() so the
+ * candle transposes under orientation flip.
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildCandleMarks({ data, plot, channels, options = {}, alpha, type = 'candlestick' }) {
+	const { xScale, yScale } = plot
+	if (!data?.length || !xScale || !yScale) return []
+
+	const open = options.open ?? 'open'
+	const high = options.high ?? 'high'
+	const low = options.low ?? 'low'
+	const close = options.close ?? 'close'
+	const upColor = options.upColor ?? '#22c55e'
+	const downColor = options.downColor ?? '#ef4444'
+	const a = resolveAlpha(alpha, type, plot.chartPreset)
+
+	const bw = typeof xScale.bandwidth === 'function' ? xScale.bandwidth() : 10
+	const bodyWidth = bw * 0.6
+	const bodyOffset = (bw - bodyWidth) / 2
+
+	return data.map((d, i) => {
+		const xPos = (xScale(d[channels.x ?? '']) ?? 0) + bodyOffset
+		const openVal = Number(d[open])
+		const closeVal = Number(d[close])
+		const isUp = closeVal >= openVal
+		const bodyTop = yScale(isUp ? closeVal : openVal)
+		const bodyBottom = yScale(isUp ? openVal : closeVal)
+
+		const b1 = plot.place(xPos, bodyTop)
+		const b2 = plot.place(xPos + bodyWidth, bodyBottom)
+		const wa = plot.place(xPos + bodyWidth / 2, yScale(Number(d[high])))
+		const wb = plot.place(xPos + bodyWidth / 2, yScale(Number(d[low])))
+		return {
+			key: `${d[channels.x ?? '']}-${i}`,
+			bodyX: Math.min(b1.x, b2.x),
+			bodyY: Math.min(b1.y, b2.y),
+			bodyWidth: Math.abs(b2.x - b1.x),
+			bodyHeight: Math.max(1, Math.abs(b2.y - b1.y)),
+			fill: isUp ? upColor : downColor,
+			alpha: a,
+			wickX1: wa.x,
+			wickY1: wa.y,
+			wickX2: wb.x,
+			wickY2: wb.y,
+			data: d
+		}
+	})
+}

package/dist/geoms/lib/marks/heatmap.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Build renderable heatmap cells. Cell fill is the continuous color scale (numeric color
+ * field) or the categorical palette entry, from `fill ?? color`. Adds fixed `alpha`.
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildHeatmapMarks({ data, plot, channels, alpha, type }: {
+    data: any[];
+    plot: any;
+    channels: any;
+    options?: any;
+    alpha?: number;
+    type?: string;
+}): {
+    key: string;
+    x: any;
+    y: any;
+    width: any;
+    height: any;
+    fill: string;
+    alpha: number;
+    value: any;
+    display: string;
+    data: any;
+}[];

package/dist/geoms/lib/marks/heatmap.js

@@ -0,0 +1,41 @@
+import { resolveAlpha } from '../aesthetics.js'
+
+/**
+ * Build renderable heatmap cells. Cell fill is the continuous color scale (numeric color
+ * field) or the categorical palette entry, from `fill ?? color`. Adds fixed `alpha`.
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildHeatmapMarks({ data, plot, channels, alpha, type = 'heatmap' }) {
+	const { xScale, yScale, colors } = plot
+	if (!data?.length || !xScale || !yScale) return []
+
+	const colorField = channels.fill ?? channels.color
+	const continuous = plot.continuousColorScale
+	const bwX = typeof xScale.bandwidth === 'function' ? xScale.bandwidth() : 0
+	const bwY = typeof yScale.bandwidth === 'function' ? yScale.bandwidth() : 0
+	const a = resolveAlpha(alpha, type, plot.chartPreset)
+
+	return data.map((d, i) => {
+		const xVal = d[channels.x ?? '']
+		const yVal = d[channels.y ?? '']
+		const colorVal = colorField ? d[colorField] : null
+		let fill = '#ccc'
+		if (continuous) fill = continuous.scale(Number(colorVal))
+		else {
+			const entry = colors?.get(colorVal)
+			if (entry) fill = entry.fill
+		}
+		return {
+			key: `${xVal}-${yVal}-${i}`,
+			x: xScale(xVal) ?? 0,
+			y: yScale(yVal) ?? 0,
+			width: bwX,
+			height: bwY,
+			fill,
+			alpha: a,
+			value: colorVal,
+			display: String(colorVal ?? ''),
+			data: d
+		}
+	})
+}

package/dist/geoms/lib/marks/hexbin.d.ts

@@ -0,0 +1,29 @@
+/** SVG path for a pointy-top hexagon of radius r, centered at the origin. */
+export function hexPath(r: any): string;
+/**
+ * Build renderable hex bins. Fill is the continuous color scale (by count) or a density-ramp
+ * rgba fallback. `alpha` is a flat multiplier on top (default 1 → unchanged).
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildHexbinMarks({ data, plot, channels, options, alpha, type }: {
+    data: any[];
+    plot: any;
+    channels: any;
+    options?: any;
+    alpha?: number;
+    type?: string;
+}): {
+    key: string;
+    cx: any;
+    cy: any;
+    count: any;
+    fill: any;
+    alpha: number;
+    value: any;
+    display: string;
+    data: {
+        count: any;
+        x: any;
+        y: any;
+    };
+}[];

package/dist/geoms/lib/marks/hexbin.js

@@ -0,0 +1,62 @@
+import { resolveAlpha } from '../aesthetics.js'
+
+/** SVG path for a pointy-top hexagon of radius r, centered at the origin. */
+export function hexPath(r) {
+	const angles = [0, 1, 2, 3, 4, 5].map((i) => ((i * 60 - 30) * Math.PI) / 180)
+	return `${angles.map((a, i) => `${i === 0 ? 'M' : 'L'}${r * Math.cos(a)},${r * Math.sin(a)}`).join('')}Z`
+}
+
+/** Group points into hexagonal bins and count per bin. */
+function hexBin(rows, xField, yField, xScale, yScale, r) {
+	const dx = r * 2 * Math.sin(Math.PI / 3)
+	const dy = r * 1.5
+	const bins = new Map()
+	for (const d of rows) {
+		const px = xScale(d[xField ?? ''])
+		const py = yScale(d[yField ?? ''])
+		if (px === null || px === undefined || py === null || py === undefined) continue
+		const col = Math.round(px / dx)
+		const row = Math.round(py / dy)
+		const cx = col * dx + (row % 2 ? dx / 2 : 0)
+		const cy = row * dy
+		const key = `${col},${row}`
+		let bin = bins.get(key)
+		if (!bin) {
+			bin = { cx, cy, count: 0, points: [] }
+			bins.set(key, bin)
+		}
+		bin.count++
+		bin.points.push(d)
+	}
+	return [...bins.values()]
+}
+
+/**
+ * Build renderable hex bins. Fill is the continuous color scale (by count) or a density-ramp
+ * rgba fallback. `alpha` is a flat multiplier on top (default 1 → unchanged).
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildHexbinMarks({ data, plot, channels, options = {}, alpha, type = 'hexbin' }) {
+	const { xScale, yScale } = plot
+	if (!data?.length || !xScale || !yScale) return []
+
+	const radius = options.radius ?? 20
+	const bins = hexBin(data, channels.x, channels.y, xScale, yScale, radius)
+	const maxCount = Math.max(1, ...bins.map((b) => b.count))
+	const colorScale = plot.continuousColorScale?.scale
+	const a = resolveAlpha(alpha, type, plot.chartPreset)
+
+	return bins.map((bin, i) => ({
+		key: `hex-${i}`,
+		cx: bin.cx,
+		cy: bin.cy,
+		count: bin.count,
+		fill: colorScale
+			? colorScale(bin.count)
+			: `rgba(66, 133, 244, ${0.1 + 0.9 * (bin.count / maxCount)})`,
+		alpha: a,
+		value: bin.count,
+		display: `${bin.count}`,
+		data: { count: bin.count, x: bin.cx, y: bin.cy }
+	}))
+}

package/dist/geoms/lib/marks/jitter.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Build renderable jitter/swarm points. Fill + outline come from `fill` (defaulting to
+ * `x`); an explicit `color` channel overrides the outline stroke. Adds fixed `alpha`.
+ * Horizontal orientation swaps each point's screen coords via place().
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildJitterMarks({ data, plot, channels, options, alpha, type }: {
+    data: any[];
+    plot: any;
+    channels: any;
+    options?: any;
+    alpha?: number;
+    type?: string;
+}): {
+    cx: any;
+    cy: any;
+    stroke: any;
+    alpha: number;
+    fill: string;
+    data: Record<string, unknown>;
+}[];