@rokkit/chart 1.3.7 → 1.3.9

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)
@@ -33,27 +34,65 @@ function subBandFields(channels) {
 	return out
 }
 
-export function buildGroupedBars(data, channels, xScale, yScale, colors, innerHeight, patterns) {
+/**
+ * The one bar builder. Expresses each bar in abstract (category, value) space and maps it to
+ * screen via `place()`, so it renders vertical or horizontal (flip) with the same code.
+ *
+ * Category (x) positioning has two modes:
+ * - band (default): a scaleBand slots each category; sub-bands split grouped series.
+ * - continuous (`continuousCategory`): a LINEAR position scale (e.g. a bar-chart race's tweened
+ *   `_rank`). Each bar centres on `xScale(pos)` with a fixed thickness from the scale step, so a
+ *   fractional position tweens smoothly (a band scale can only jump between slots). No sub-banding.
+ */
+export function buildBars(
+	data,
+	channels,
+	xScale,
+	yScale,
+	colors,
+	innerHeight,
+	patterns,
+	place = (x, y) => ({ x, y }),
+	continuousCategory = false,
+	dodge = true
+) {
 	const { x: xf, y: yf, color: cf, pattern: pf } = channels
 
-	const bandScale = ensureBandX(xScale, data, xf)
-
-	// Sub-banding: only fields that differ from x drive grouping within a band
-	const subFields = 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('::')
-	const subDomain = subFields.length > 0 ? [...new Set(data.map(getSubKey))] : []
-	const subScale =
-		subDomain.length > 1
-			? scaleBand().domain(subDomain).range([0, bandScale.bandwidth()]).padding(0.05)
-			: null
-
-	// Baseline for bars: at y=0 when domain spans zero (supports negative bars),
-	// otherwise at the bottom of the chart area.
+
+	let positionOf
+	let thicknessOf
+	if (continuousCategory) {
+		const [r0, r1] = xScale.range()
+		const [d0, d1] = xScale.domain()
+		const step = Math.max(Math.abs(r0 - r1) / Math.max(d1 - d0, 1), 1)
+		const thickness = step * 0.9
+		thicknessOf = () => thickness
+		positionOf = (d) => (xScale(Number(d[xf])) ?? 0) - thickness / 2
+	} else {
+		const bandScale = ensureBandX(xScale, data, xf)
+		const subDomain = subFields.length > 0 ? [...new Set(data.map(getSubKey))] : []
+		const subScale =
+			subDomain.length > 1
+				? scaleBand().domain(subDomain).range([0, bandScale.bandwidth()]).padding(0.05)
+				: null
+		thicknessOf = () => (subScale ? subScale.bandwidth() : bandScale.bandwidth())
+		positionOf = (d) => {
+			const bandX = bandScale(d[xf]) ?? 0
+			const subX = subScale ? (subScale(getSubKey(d)) ?? 0) : 0
+			return bandX + subX
+		}
+	}
+
+	// Value baseline: at value=0 when the domain spans zero (supports negative bars), else the
+	// value-axis origin (yScale.range()[0] — innerHeight when vertical, 0 when flipped).
 	const yDomain = typeof yScale.bandwidth !== 'function' ? yScale.domain?.() : null
 	const baseline =
 		yDomain && yDomain[0] <= 0 && yDomain[yDomain.length - 1] >= 0
-			? (yScale(0) ?? innerHeight)
-			: innerHeight
+			? (yScale(0) ?? yScale.range()[0])
+			: yScale.range()[0]
 
 	return data.map((d, i) => {
 		const xVal = d[xf]
@@ -68,19 +107,26 @@ export function buildGroupedBars(data, channels, xScale, yScale, colors, innerHe
 				? toPatternId(String(patternKey))
 				: null
 
-		const bandX = bandScale(xVal) ?? 0
-		const subX = subScale && subKey ? (subScale(subKey) ?? 0) : 0
-		const barX = bandX + subX
-		const barWidth = subScale ? subScale.bandwidth() : bandScale.bandwidth()
-		const barY = yScale(d[yf]) ?? baseline
+		const barBand = positionOf(d)
+		const barThickness = thicknessOf(d)
+		const barValue = yScale(d[yf]) ?? baseline
+		// Two opposite corners in (band, value) space, placed to screen — transposes under flip.
+		const c1 = place(barBand, baseline)
+		const c2 = place(barBand + barThickness, barValue)
+
+		// Continuous mode keys by _entity so Svelte reuses each bar as its position tweens (a
+		// race's rows reorder every frame); band mode keys by category + sub-band + index.
+		const key = continuousCategory
+			? `${String(d._entity ?? xVal)}::${String(colorKey ?? '')}`
+			: `${String(xVal)}::${subKey}::${i}`
 
 		return {
 			data: d,
-			key: `${String(xVal)}::${subKey}::${i}`,
-			x: barX,
-			y: Math.min(barY, baseline),
-			width: barWidth,
-			height: Math.abs(baseline - barY),
+			key,
+			x: Math.min(c1.x, c2.x),
+			y: Math.min(c1.y, c2.y),
+			width: Math.abs(c2.x - c1.x),
+			height: Math.abs(c2.y - c1.y),
 			fill: colorEntry.fill,
 			stroke: colorEntry.stroke,
 			patternId
@@ -88,7 +134,7 @@ export function buildGroupedBars(data, channels, xScale, yScale, colors, innerHe
 	})
 }
 
-export function buildStackedBars(data, channels, xScale, yScale, colors, innerHeight, patterns) {
+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)
@@ -96,7 +142,7 @@ export function buildStackedBars(data, channels, xScale, yScale, colors, innerHe
 	// Stack dimension: first non-x grouping field (prefer pattern, then color)
 	const subFields = subBandFields(channels)
 	if (subFields.length === 0) {
-		return buildGroupedBars(data, channels, xScale, yScale, colors, innerHeight, patterns)
+		return buildBars(data, channels, xScale, yScale, colors, innerHeight, patterns, place)
 	}
 	const stackField = subFields[0]
 
@@ -116,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 = []
@@ -152,72 +200,3 @@ export function buildStackedBars(data, channels, xScale, yScale, colors, innerHe
 	}
 	return bars
 }
-
-export function buildHorizontalBars(data, channels, xScale, yScale, colors, _innerHeight) {
-	const { x: xf, y: yf, color: cf } = channels
-	const isBand = typeof yScale?.bandwidth === 'function'
-
-	if (!isBand) {
-		// Linear y-scale: rank-based bar chart race.
-		// Each row has a numeric _rank that tweens smoothly between frames.
-		// No sub-grouping — each rank position holds exactly one entity.
-		const [r0, r1] = yScale.range() // [innerHeight, 0]
-		const [d0, d1] = yScale.domain() // [0, N-1]
-		const step = Math.max(Math.abs(r0 - r1) / Math.max(d1 - d0, 1), 1)
-		const barH = step * 0.9
-
-		return data.map((d) => {
-			const rankVal = Number(d[yf])
-			const colorKey = cf ? d[cf] : null
-			const colorEntry =
-				colors?.get(colorKey) ??
-				colors?.values().next().value ?? { fill: '#888', stroke: '#888' }
-
-			const centerY = yScale(rankVal) ?? 0
-			return {
-				data: d,
-				// Key by entity name (_entity) so Svelte reuses elements as rank tweens
-				key: `${String(d._entity ?? d[yf])}::${String(colorKey ?? '')}`,
-				x: 0,
-				y: centerY - barH / 2,
-				width: xScale(d[xf]) ?? 0,
-				height: barH,
-				fill: colorEntry.fill,
-				stroke: colorEntry.stroke,
-				patternId: null
-			}
-		})
-	}
-
-	// Band scale: standard grouped horizontal bars.
-	// Only create sub-bands when multiple entities share the same y-band (true grouping).
-	const yVals = new Set(data.map((d) => d[yf]))
-	const colorKeys = cf && !isLiteralColor(cf) ? [...new Set(data.map((d) => d[cf]))] : []
-	const hasSubBands = colorKeys.length > 1 && data.length > yVals.size
-	const subScale = hasSubBands
-		? scaleBand().domain(colorKeys).range([0, yScale.bandwidth()]).padding(0.05)
-		: null
-
-	return data.map((d) => {
-		const yVal = d[yf]
-		const colorKey = cf ? d[cf] : null
-		const colorEntry =
-			colors?.get(colorKey) ??
-			colors?.values().next().value ?? { fill: '#888', stroke: '#888' }
-
-		const bandY = yScale(yVal) ?? 0
-		const subY = subScale ? (subScale(colorKey) ?? 0) : 0
-
-		return {
-			data: d,
-			key: `${String(yVal)}::${String(colorKey ?? '')}`,
-			x: 0,
-			y: bandY + subY,
-			width: xScale(d[xf]) ?? 0,
-			height: subScale ? subScale.bandwidth() : yScale.bandwidth(),
-			fill: colorEntry.fill,
-			stroke: colorEntry.stroke,
-			patternId: null
-		}
-	})
-}

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;
+    };
+}[];