@rokkit/chart 1.7.0 → 1.8.1

package/dist/geoms/Rule.svelte

@@ -1,6 +1,7 @@
 <script lang="ts">
 	import { getContext } from 'svelte'
 	import type { PlotState } from '../PlotState.svelte.js'
+	import { clipAbline, slopeLabel } from '../lib/abline.js'
 
 	type RuleValue = number | string
 	type Props = {
@@ -8,6 +9,14 @@
 		x?: RuleValue | RuleValue[]
 		/** Horizontal reference line(s) at these y-axis value(s). */
 		y?: RuleValue | RuleValue[]
+		/**
+		 * A sloped line `y = slope·x + intercept` (ggplot's `abline`), clipped to the visible
+		 * domain. Continuous axes only — a slope over categories has no meaning, so it is
+		 * ignored on a band axis. The main sequence is `slope={-1} intercept={1}`.
+		 */
+		slope?: number
+		/** Where the sloped line crosses x = 0. Defaults to 0. */
+		intercept?: number
 		/** Line color (aligns with the other geoms' `color` aesthetic). */
 		color?: string
 		/** @deprecated use `color` — kept as an alias. */
@@ -22,6 +31,8 @@
 	let {
 		x,
 		y,
+		slope = undefined,
+		intercept = 0,
 		color = undefined,
 		stroke = undefined,
 		dash = '4 4',
@@ -37,7 +48,10 @@
 		v === undefined ? [] : Array.isArray(v) ? v : [v]
 
 	// Position along an axis: band scales resolve to the band centre, linear scales map directly.
-	function axisPos(scale: { (v: unknown): number | undefined; bandwidth?: () => number }, v: unknown) {
+	function axisPos(
+		scale: { (v: unknown): number | undefined; bandwidth?: () => number },
+		v: unknown
+	) {
 		const base = scale(v) ?? 0
 		return typeof scale.bandwidth === 'function' ? base + scale.bandwidth() / 2 : base
 	}
@@ -50,37 +64,72 @@
 	const labelFor = (v: RuleValue) =>
 		typeof label === 'function' ? label(v) : typeof label === 'string' ? label : null
 
+	type Point = { x: number; y: number }
+	type RuleLine = {
+		key: string
+		x1: number
+		y1: number
+		x2: number
+		y2: number
+		value: RuleValue
+		text: string | null
+		kind: 'x' | 'y' | 'slope'
+	}
+
+	const lineOf = (id: Pick<RuleLine, 'key' | 'kind' | 'value'>, a: Point, b: Point): RuleLine => ({
+		...id,
+		x1: a.x,
+		y1: a.y,
+		x2: b.x,
+		y2: b.y,
+		text: labelFor(id.value)
+	})
+
+	type AnyScale = {
+		(v: unknown): number | undefined
+		bandwidth?: () => number
+		domain: () => unknown[]
+	}
+	const isBand = (scale: AnyScale) => typeof scale.bandwidth === 'function'
+
+	// The sloped line, clipped in DATA space so it stays inside the plot at any zoom. A band
+	// axis has no numeric domain to clip against, so the slope is ignored there.
+	function slopeLine(
+		xs: AnyScale,
+		ys: AnyScale,
+		place: (u: number, v: number) => Point
+	): RuleLine | null {
+		if (slope === undefined || isBand(xs) || isBand(ys)) return null
+		const seg = clipAbline(
+			slope,
+			intercept,
+			xs.domain() as [number, number],
+			ys.domain() as [number, number]
+		)
+		if (!seg) return null
+		const a = place(Number(xs(seg.x1)), Number(ys(seg.y1)))
+		const b = place(Number(xs(seg.x2)), Number(ys(seg.y2)))
+		return lineOf({ key: `slope-${slope}-${intercept}`, kind: 'slope', value: slope }, a, b)
+	}
+
 	// Each rule is expressed in (x-channel, y-channel) space and placed to screen, so it
 	// transposes under orientation flip: a y-value reference is horizontal when vertical and
 	// vertical when flipped (it stays perpendicular to the value axis).
-	const rules = $derived.by(() => {
+	const rules = $derived.by((): RuleLine[] => {
 		if (!xScale || !yScale) return []
 		const place = plotState.place.bind(plotState)
-		const out: Array<{
-			key: string
-			x1: number
-			y1: number
-			x2: number
-			y2: number
-			value: RuleValue
-			text: string | null
-		}> = []
 		const [xLo, xHi] = axisExtent(xScale)
 		const [yLo, yHi] = axisExtent(yScale)
-
-		for (const yv of toArray(y)) {
+		const horizontal = toArray(y).map((yv) => {
 			const yc = axisPos(yScale, yv)
-			const a = place(xLo, yc)
-			const b = place(xHi, yc)
-			out.push({ key: `y-${yv}`, x1: a.x, y1: a.y, x2: b.x, y2: b.y, value: yv, text: labelFor(yv) })
-		}
-		for (const xv of toArray(x)) {
+			return lineOf({ key: `y-${yv}`, kind: 'y', value: yv }, place(xLo, yc), place(xHi, yc))
+		})
+		const vertical = toArray(x).map((xv) => {
 			const xc = axisPos(xScale, xv)
-			const a = place(xc, yLo)
-			const b = place(xc, yHi)
-			out.push({ key: `x-${xv}`, x1: a.x, y1: a.y, x2: b.x, y2: b.y, value: xv, text: labelFor(xv) })
-		}
-		return out
+			return lineOf({ key: `x-${xv}`, kind: 'x', value: xv }, place(xc, yLo), place(xc, yHi))
+		})
+		const sloped = slopeLine(xScale, yScale, place)
+		return sloped ? [...horizontal, ...vertical, sloped] : [...horizontal, ...vertical]
 	})
 
 	const strokeColor = $derived(color ?? stroke ?? 'currentColor')
@@ -98,9 +147,22 @@
 				stroke-width={strokeWidth}
 				stroke-dasharray={dash || undefined}
 				data-plot-element="rule"
+				data-plot-rule={rule.kind}
 				data-plot-value={rule.value}
 			/>
-			{#if rule.text}
+			{#if rule.text && rule.kind === 'slope'}
+				{@const at = slopeLabel(rule)}
+				<text
+					x={at.x}
+					y={at.y}
+					dy="-5"
+					text-anchor="middle"
+					transform="rotate({at.angle} {at.x} {at.y})"
+					font-size="10"
+					fill={strokeColor}
+					data-plot-element="rule-label">{rule.text}</text
+				>
+			{:else if rule.text}
 				<text
 					x={rule.x2}
 					y={rule.y2}
@@ -109,8 +171,8 @@
 					text-anchor="end"
 					font-size="10"
 					fill={strokeColor}
-					data-plot-element="rule-label"
-				>{rule.text}</text>
+					data-plot-element="rule-label">{rule.text}</text
+				>
 			{/if}
 		{/each}
 	</g>

package/dist/geoms/Rule.svelte.d.ts

@@ -4,6 +4,14 @@ type Props = {
     x?: RuleValue | RuleValue[];
     /** Horizontal reference line(s) at these y-axis value(s). */
     y?: RuleValue | RuleValue[];
+    /**
+     * A sloped line `y = slope·x + intercept` (ggplot's `abline`), clipped to the visible
+     * domain. Continuous axes only — a slope over categories has no meaning, so it is
+     * ignored on a band axis. The main sequence is `slope={-1} intercept={1}`.
+     */
+    slope?: number;
+    /** Where the sloped line crosses x = 0. Defaults to 0. */
+    intercept?: number;
     /** Line color (aligns with the other geoms' `color` aesthetic). */
     color?: string;
     /** @deprecated use `color` — kept as an alias. */

package/dist/geoms/lib/PlotAreaClip.svelte

@@ -0,0 +1,18 @@
+<script lang="ts">
+	/**
+	 * A clip path the size of the plot area, for geoms whose shapes can legitimately extend
+	 * past the domain — a region polygon drawn beyond the axes, a density ring whose kernel
+	 * reaches past the last point. Clipped, they stop at the axes instead of painting over them.
+	 */
+	import { getContext } from 'svelte'
+	import type { PlotState } from '../../PlotState.svelte.js'
+
+	let { id }: { id: string } = $props()
+	const plotState = getContext<PlotState>('plot-state')
+</script>
+
+<defs>
+	<clipPath {id}>
+		<rect x="0" y="0" width={plotState.innerWidth} height={plotState.innerHeight} />
+	</clipPath>
+</defs>

package/dist/geoms/lib/PlotAreaClip.svelte.d.ts

@@ -0,0 +1,6 @@
+type $$ComponentProps = {
+    id: string;
+};
+declare const PlotAreaClip: import("svelte").Component<$$ComponentProps, {}, "">;
+type PlotAreaClip = ReturnType<typeof PlotAreaClip>;
+export default PlotAreaClip;

package/dist/geoms/lib/bars.js

@@ -1,7 +1,8 @@
 import { scaleBand } from 'd3-scale'
 import { stack, stackOffsetExpand } from 'd3-shape'
 import { toPatternId } from '../../lib/brewing/patterns.js'
-import { isLiteralColor, literalColor, markEntry } from '../../lib/brewing/colors.js'
+import { literalColor, markEntry } from '../../lib/brewing/colors.js'
+import { subBandFields } from '../../lib/plot/stacking.js'
 
 /**
  * Returns a band scale suitable for bar x-positioning.
@@ -16,24 +17,6 @@ function ensureBandX(xScale, data, xField) {
 	return scaleBand().domain(domain).range([r0, r1]).padding(0.2)
 }
 
-/**
- * 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, group: gf, color: cf, pattern: pf } = channels
-	const seen = new Set()
-	const out = []
-	for (const f of [gf, cf, pf]) {
-		if (f && f !== xf && !seen.has(f) && !isLiteralColor(f)) {
-			seen.add(f)
-			out.push(f)
-		}
-	}
-	return out
-}
-
 /**
  * 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.
@@ -141,7 +124,17 @@ export function buildBars(
 	})
 }
 
-export function buildStackedBars(data, channels, xScale, yScale, colors, innerHeight, patterns, place = (x, y) => ({ x, y }), normalize = false) {
+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 lit = literalColor(cf)
 	const field = lit ? undefined : cf

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

@@ -0,0 +1,35 @@
+/**
+ * Shared by the geoms that summarise GROUPS of points (Hull, Contour) rather than drawing one
+ * mark per row: bucket rows by the group field, and place each row on screen — or drop it
+ * when it has no usable coordinate, which is a normal state in a partially-measured dataset.
+ */
+/**
+ * Screen position of one value on a scale, or null when the row has no usable coordinate
+ * (null / empty / a category the scale does not know / NaN). A band category resolves to its
+ * centre, where a point in that category is drawn.
+ *
+ * @param {any} scale
+ * @param {unknown} v
+ * @returns {number | null}
+ */
+export function coordOf(scale: any, v: unknown): number | null;
+/**
+ * Rows bucketed by `field`, in first-seen order. One bucket (key `null`) without a field.
+ *
+ * @param {Record<string, unknown>[]} data
+ * @param {string | undefined} field
+ * @returns {Map<unknown, Record<string, unknown>[]>}
+ */
+export function groupRows(data: Record<string, unknown>[], field: string | undefined): Map<unknown, Record<string, unknown>[]>;
+/**
+ * Screen points for rows, after orientation `place`, skipping rows with no coordinate.
+ *
+ * @param {Record<string, unknown>[]} rows
+ * @param {any} plot
+ * @param {{ x?: string, y?: string }} channels
+ * @returns {Array<[number, number]>}
+ */
+export function screenPoints(rows: Record<string, unknown>[], plot: any, channels: {
+    x?: string;
+    y?: string;
+}): Array<[number, number]>;

package/dist/geoms/lib/grouping.js

@@ -0,0 +1,59 @@
+/**
+ * Shared by the geoms that summarise GROUPS of points (Hull, Contour) rather than drawing one
+ * mark per row: bucket rows by the group field, and place each row on screen — or drop it
+ * when it has no usable coordinate, which is a normal state in a partially-measured dataset.
+ */
+
+/**
+ * Screen position of one value on a scale, or null when the row has no usable coordinate
+ * (null / empty / a category the scale does not know / NaN). A band category resolves to its
+ * centre, where a point in that category is drawn.
+ *
+ * @param {any} scale
+ * @param {unknown} v
+ * @returns {number | null}
+ */
+export function coordOf(scale, v) {
+	if (v === null || v === undefined || v === '') return null
+	const s = scale(v)
+	if (s === null || s === undefined || Number.isNaN(s)) return null
+	return typeof scale.bandwidth === 'function' ? s + scale.bandwidth() / 2 : s
+}
+
+/**
+ * Rows bucketed by `field`, in first-seen order. One bucket (key `null`) without a field.
+ *
+ * @param {Record<string, unknown>[]} data
+ * @param {string | undefined} field
+ * @returns {Map<unknown, Record<string, unknown>[]>}
+ */
+export function groupRows(data, field) {
+	const groups = new Map()
+	for (const row of data) {
+		const key = field ? row[field] : null
+		if (!groups.has(key)) groups.set(key, [])
+		groups.get(key).push(row)
+	}
+	return groups
+}
+
+/**
+ * Screen points for rows, after orientation `place`, skipping rows with no coordinate.
+ *
+ * @param {Record<string, unknown>[]} rows
+ * @param {any} plot
+ * @param {{ x?: string, y?: string }} channels
+ * @returns {Array<[number, number]>}
+ */
+export function screenPoints(rows, plot, channels) {
+	/** @type {Array<[number, number]>} */
+	const pts = []
+	for (const row of rows) {
+		const u = coordOf(plot.xScale, row[channels.x ?? ''])
+		const v = coordOf(plot.yScale, row[channels.y ?? ''])
+		if (u === null || v === null) continue
+		const p = plot.place(u, v)
+		pts.push([p.x, p.y])
+	}
+	return pts
+}

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

@@ -13,6 +13,7 @@ export function buildArcMarks({ data, plot, channels, options, alpha, type }: {
     type?: string;
 }): {
     alpha: number;
+    id: string;
     d: string | null;
     fill: string;
     stroke: string;

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

@@ -0,0 +1,26 @@
+/**
+ * SVG path data for a GeoJSON MultiPolygon's coordinates — every ring of every polygon a
+ * closed subpath, so holes cut out under the default nonzero/evenodd rules d3-contour's
+ * winding produces.
+ *
+ * @param {number[][][][]} coordinates
+ */
+export function multiPolygonPath(coordinates: number[][][][]): string;
+/**
+ * Kernel-density contours per group of the `fill` (else `color`) field.
+ *
+ * Density is estimated in SCREEN space over the plot area, so `bandwidth` is in pixels — the
+ * unit a reader judges smoothness in — and the result is the same at any data scale. Level 0
+ * is the outermost (lowest-density) ring; filled bands ramp opacity toward `alpha` at the
+ * densest core, so pile-ups read darkest.
+ *
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildContourMarks({ data, plot, channels, options, alpha, type }: {
+    data: any[];
+    plot: any;
+    channels: any;
+    options?: any;
+    alpha?: number;
+    type?: string;
+}): any[];

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

@@ -0,0 +1,67 @@
+import { contourDensity } from 'd3-contour'
+import { resolveFillStroke, resolveAlpha } from '../aesthetics.js'
+import { groupRows, screenPoints } from '../grouping.js'
+
+/**
+ * SVG path data for a GeoJSON MultiPolygon's coordinates — every ring of every polygon a
+ * closed subpath, so holes cut out under the default nonzero/evenodd rules d3-contour's
+ * winding produces.
+ *
+ * @param {number[][][][]} coordinates
+ */
+export function multiPolygonPath(coordinates) {
+	const fmt = (/** @type {number} */ n) => Math.round(n * 100) / 100
+	return coordinates
+		.flatMap((polygon) =>
+			polygon.map((ring) => `M${ring.map(([x, y]) => `${fmt(x)},${fmt(y)}`).join('L')}Z`)
+		)
+		.join('')
+}
+
+/**
+ * Kernel-density contours per group of the `fill` (else `color`) field.
+ *
+ * Density is estimated in SCREEN space over the plot area, so `bandwidth` is in pixels — the
+ * unit a reader judges smoothness in — and the result is the same at any data scale. Level 0
+ * is the outermost (lowest-density) ring; filled bands ramp opacity toward `alpha` at the
+ * densest core, so pile-ups read darkest.
+ *
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildContourMarks({ data, plot, channels, options = {}, alpha, type = 'contour' }) {
+	if (!data?.length || !plot.xScale || !plot.yScale) return []
+	const groupField = channels.fill ?? channels.color
+	const a = resolveAlpha(alpha, type, plot.chartPreset)
+	const w = Math.max(1, Math.round(plot.innerWidth))
+	const h = Math.max(1, Math.round(plot.innerHeight))
+
+	const marks = []
+	for (const [key, rows] of groupRows(data, groupField)) {
+		const pts = screenPoints(rows, plot, channels)
+		if (pts.length === 0) continue
+		const density = contourDensity()
+			.x((d) => d[0])
+			.y((d) => d[1])
+			.size([w, h])
+			.bandwidth(options.bandwidth ?? 20)
+			.thresholds(options.thresholds ?? 8)(pts)
+		const { fill, stroke } = resolveFillStroke(
+			rows[0],
+			{ fill: channels.fill, color: channels.color },
+			plot.colors
+		)
+		density.forEach((level, i) => {
+			marks.push({
+				key: `contour-${String(key)}-${i}`,
+				group: key,
+				level: i,
+				value: level.value,
+				d: multiPolygonPath(level.coordinates),
+				fill,
+				stroke,
+				fillAlpha: (a * (i + 1)) / density.length
+			})
+		})
+	}
+	return marks
+}

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

@@ -0,0 +1,26 @@
+/**
+ * One outline per group of the `fill` (else `color`) channel — ggplot's discrete-colour
+ * grouping. The hull is computed in SCREEN space after `place`, so it is convex as drawn,
+ * whatever the scales (a hull in data space is not convex on a log axis).
+ *
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildHullMarks({ data, plot, channels, alpha, type }: {
+    data: any[];
+    plot: any;
+    channels: any;
+    options?: any;
+    alpha?: number;
+    type?: string;
+}): {
+    key: string;
+    group: unknown;
+    d: string;
+    fill: string;
+    alpha: number;
+    at: {
+        x: number;
+        y: number;
+    };
+    count: number;
+}[];

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

@@ -0,0 +1,36 @@
+import { convexHull, hullPath } from '../../../lib/hull.js'
+import { centroid } from '../../../lib/region.js'
+import { resolveFillStroke, resolveAlpha } from '../aesthetics.js'
+import { groupRows, screenPoints } from '../grouping.js'
+
+/**
+ * One outline per group of the `fill` (else `color`) channel — ggplot's discrete-colour
+ * grouping. The hull is computed in SCREEN space after `place`, so it is convex as drawn,
+ * whatever the scales (a hull in data space is not convex on a log axis).
+ *
+ * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
+ */
+export function buildHullMarks({ data, plot, channels, alpha, type = 'hull' }) {
+	const { xScale, yScale, colors } = plot
+	if (!data?.length || !xScale || !yScale) return []
+	const groupField = channels.fill ?? channels.color
+	const a = resolveAlpha(alpha, type, plot.chartPreset)
+
+	const marks = []
+	for (const [key, rows] of groupRows(data, groupField)) {
+		const pts = screenPoints(rows, plot, channels)
+		if (pts.length === 0) continue
+		const hull = convexHull(pts)
+		const { fill } = resolveFillStroke(rows[0], { fill: groupField }, colors)
+		marks.push({
+			key: `hull-${String(key)}`,
+			group: key,
+			d: hullPath(hull),
+			fill,
+			alpha: a,
+			at: centroid(hull.map(([x, y]) => ({ x, y }))),
+			count: rows.length
+		})
+	}
+	return marks
+}

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

@@ -1,11 +1,19 @@
 import { resolveAlpha } from '../aesthetics.js'
+import { runningSpans } from '../../../lib/plot/running.js'
 
 /**
  * Build renderable waterfall bars. Bar color is semantic (positive/negative/total from
  * options), not the shared palette. Adds fixed `alpha` and carries connector anchors.
  * @param {{ data: any[], plot: any, channels: any, options?: any, alpha?: number, type?: string }} ctx
  */
-export function buildWaterfallMarks({ data, plot, channels, options = {}, alpha, type = 'waterfall' }) {
+export function buildWaterfallMarks({
+	data,
+	plot,
+	channels,
+	options = {},
+	alpha,
+	type = 'waterfall'
+}) {
 	const { xScale, yScale } = plot
 	if (!data?.length || !xScale || !yScale) return []
 
@@ -16,28 +24,15 @@ export function buildWaterfallMarks({ data, plot, channels, options = {}, alpha,
 	const a = resolveAlpha(alpha, type, plot.chartPreset)
 
 	const bw = typeof xScale.bandwidth === 'function' ? xScale.bandwidth() : 10
-	let cumulative = 0
+	const spans = runningSpans(data, channels.y ?? '', totalField)
 
 	return data.map((d, i) => {
 		const xVal = d[channels.x ?? '']
-		const yVal = Number(d[channels.y ?? ''])
-		const isTotal = totalField ? Boolean(d[totalField]) : false
+		const { lo, hi, total, isTotal, delta } = spans[i]
 		const xPos = xScale(xVal) ?? 0
-		let barTop
-		let barBottom
-		let fill
-
-		if (isTotal) {
-			barTop = yScale(Math.max(0, cumulative)) ?? 0
-			barBottom = yScale(0) ?? 0
-			fill = totalColor
-		} else {
-			const start = cumulative
-			cumulative += yVal
-			barTop = yScale(Math.max(start, cumulative)) ?? 0
-			barBottom = yScale(Math.min(start, cumulative)) ?? 0
-			fill = yVal >= 0 ? positiveColor : negativeColor
-		}
+		const barTop = yScale(hi) ?? 0
+		const barBottom = yScale(lo) ?? 0
+		const fill = isTotal ? totalColor : delta >= 0 ? positiveColor : negativeColor
 
 		const c1 = plot.place(xPos, barTop)
 		const c2 = plot.place(xPos + bw, barBottom)
@@ -51,7 +46,7 @@ export function buildWaterfallMarks({ data, plot, channels, options = {}, alpha,
 			alpha: a,
 			bandStart: xPos,
 			bandEnd: xPos + bw,
-			cumY: yScale(cumulative) ?? 0,
+			cumY: yScale(total) ?? 0,
 			data: d
 		}
 	})

package/dist/index.d.ts

@@ -19,6 +19,9 @@ export namespace Plot {
     export { Ribbon };
     export { Waterfall };
     export { Rule };
+    export { Region };
+    export { Hull };
+    export { Contour };
     export { Radar };
 }
 export namespace PlotLayers { }
@@ -45,6 +48,9 @@ export { default as GeomHighlight } from "./geoms/Highlight.svelte";
 export { default as GeomTrend } from "./geoms/Trend.svelte";
 export { default as GeomJitter } from "./geoms/Jitter.svelte";
 export { default as GeomRule } from "./geoms/Rule.svelte";
+export { default as GeomRegion } from "./geoms/Region.svelte";
+export { default as GeomHull } from "./geoms/Hull.svelte";
+export { default as GeomContour } from "./geoms/Contour.svelte";
 export { default as Chart } from "./Chart.svelte";
 export { default as Sparkline } from "./Sparkline.svelte";
 export { default as Spark } from "./Spark.svelte";
@@ -83,6 +89,9 @@ import Hexbin from './geoms/Hexbin.svelte';
 import Ribbon from './geoms/Ribbon.svelte';
 import Waterfall from './geoms/Waterfall.svelte';
 import Rule from './geoms/Rule.svelte';
+import Region from './geoms/Region.svelte';
+import Hull from './geoms/Hull.svelte';
+import Contour from './geoms/Contour.svelte';
 import Radar from './geoms/Radar.svelte';
 export { createChartPreset, defaultPreset } from "./lib/preset.js";
 export { SparkState, GEOM_CONTRACT } from "./SparkState.svelte.js";

package/dist/index.js

@@ -18,6 +18,9 @@ import Hexbin from './geoms/Hexbin.svelte'
 import Ribbon from './geoms/Ribbon.svelte'
 import Waterfall from './geoms/Waterfall.svelte'
 import Rule from './geoms/Rule.svelte'
+import Region from './geoms/Region.svelte'
+import Hull from './geoms/Hull.svelte'
+import Contour from './geoms/Contour.svelte'
 import Radar from './geoms/Radar.svelte'
 
 // Composable Plot primitives — use as <Plot.Root>, <Plot.Axis>, <Plot.Bar>, etc.
@@ -42,6 +45,9 @@ export const Plot = {
 	Ribbon,
 	Waterfall,
 	Rule,
+	Region,
+	Hull,
+	Contour,
 	Radar
 }
 
@@ -77,6 +83,9 @@ export { default as GeomHighlight } from './geoms/Highlight.svelte'
 export { default as GeomTrend } from './geoms/Trend.svelte'
 export { default as GeomJitter } from './geoms/Jitter.svelte'
 export { default as GeomRule } from './geoms/Rule.svelte'
+export { default as GeomRegion } from './geoms/Region.svelte'
+export { default as GeomHull } from './geoms/Hull.svelte'
+export { default as GeomContour } from './geoms/Contour.svelte'
 
 // Export standalone components
 export { default as Chart } from './Chart.svelte'