@rokkit/chart 1.7.0 → 1.8.1

package/dist/lib/abline.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The segment of `y = slope·x + intercept` that lies inside a rectangular domain, or null
+ * when the line misses it.
+ *
+ * Clipping in DATA space, not pixels, is what keeps a reference line honest under zoom: the
+ * scales' domains are already the visible window, so the same call is correct at any zoom.
+ * A line that merely touches a corner returns a zero-length segment rather than null — it is
+ * inside the domain, just barely.
+ *
+ * @param {number} slope
+ * @param {number} intercept
+ * @param {[number, number]} xDomain
+ * @param {[number, number]} yDomain
+ * @returns {{ x1: number, y1: number, x2: number, y2: number } | null}
+ */
+export function clipAbline(slope: number, intercept: number, xDomain: [number, number], yDomain: [number, number]): {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+} | null;
+/**
+ * Where a sloped line's label goes: its midpoint, rotated to run along it.
+ *
+ * Not the end, where an axis-aligned rule puts its label — a sloped line's ends are corners
+ * of the plot, exactly where points and axis ticks crowd. The angle is folded into
+ * (-90°, 90°] so the text never reads upside down, whichever way the line was drawn.
+ *
+ * @param {{ x1: number, y1: number, x2: number, y2: number }} seg  screen coordinates
+ * @returns {{ x: number, y: number, angle: number }}
+ */
+export function slopeLabel({ x1, y1, x2, y2 }: {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}): {
+    x: number;
+    y: number;
+    angle: number;
+};

package/dist/lib/abline.js

@@ -0,0 +1,51 @@
+/**
+ * The segment of `y = slope·x + intercept` that lies inside a rectangular domain, or null
+ * when the line misses it.
+ *
+ * Clipping in DATA space, not pixels, is what keeps a reference line honest under zoom: the
+ * scales' domains are already the visible window, so the same call is correct at any zoom.
+ * A line that merely touches a corner returns a zero-length segment rather than null — it is
+ * inside the domain, just barely.
+ *
+ * @param {number} slope
+ * @param {number} intercept
+ * @param {[number, number]} xDomain
+ * @param {[number, number]} yDomain
+ * @returns {{ x1: number, y1: number, x2: number, y2: number } | null}
+ */
+export function clipAbline(slope, intercept, xDomain, yDomain) {
+	const [x0, x1] = [Math.min(...xDomain), Math.max(...xDomain)]
+	const [y0, y1] = [Math.min(...yDomain), Math.max(...yDomain)]
+	const at = (x) => slope * x + intercept
+
+	if (slope === 0) {
+		return intercept < y0 || intercept > y1
+			? null
+			: { x1: x0, y1: intercept, x2: x1, y2: intercept }
+	}
+
+	// Where the line crosses the lower and upper y bounds, ordered along x.
+	const xAtY0 = (y0 - intercept) / slope
+	const xAtY1 = (y1 - intercept) / slope
+	const lo = Math.max(x0, Math.min(xAtY0, xAtY1))
+	const hi = Math.min(x1, Math.max(xAtY0, xAtY1))
+	if (lo > hi) return null
+	return { x1: lo, y1: at(lo), x2: hi, y2: at(hi) }
+}
+
+/**
+ * Where a sloped line's label goes: its midpoint, rotated to run along it.
+ *
+ * Not the end, where an axis-aligned rule puts its label — a sloped line's ends are corners
+ * of the plot, exactly where points and axis ticks crowd. The angle is folded into
+ * (-90°, 90°] so the text never reads upside down, whichever way the line was drawn.
+ *
+ * @param {{ x1: number, y1: number, x2: number, y2: number }} seg  screen coordinates
+ * @returns {{ x: number, y: number, angle: number }}
+ */
+export function slopeLabel({ x1, y1, x2, y2 }) {
+	let angle = (Math.atan2(y2 - y1, x2 - x1) * 180) / Math.PI
+	if (angle > 90) angle -= 180
+	if (angle <= -90) angle += 180
+	return { x: (x1 + x2) / 2, y: (y1 + y2) / 2, angle }
+}

package/dist/lib/brewing/marks/arcs.d.ts

@@ -7,7 +7,11 @@
  * @param {number} height
  * @param {{ innerRadius?: number }} opts
  * @param {Map<unknown, string>} [patterns]
- * @returns {{ d: string | null, fill: string, stroke: string, key: unknown, patternId: string | null, pct: number, centroid: [number, number], data: Record<string, unknown> }[]}
+ * `key` is the slice's category — what picks its colour and pattern — so it repeats when rows
+ * share a category, and is undefined without a colour field. `id` is unique per slice (the key
+ * plus its occurrence), for keyed rendering; stable across updates while categories are unique.
+ *
+ * @returns {{ id: string, d: string | null, fill: string, stroke: string, key: unknown, patternId: string | null, pct: number, centroid: [number, number], data: Record<string, unknown> }[]}
  */
 export function buildArcs(data: Record<string, unknown>[], channels: {
     color?: string;
@@ -16,6 +20,7 @@ export function buildArcs(data: Record<string, unknown>[], channels: {
 }, colors: Map<any, any>, width: number, height: number, opts?: {
     innerRadius?: number;
 }, patterns?: Map<unknown, string>): {
+    id: string;
     d: string | null;
     fill: string;
     stroke: string;

package/dist/lib/brewing/marks/arcs.js

@@ -11,7 +11,11 @@ import { literalColor, markEntry } from '../colors.js'
  * @param {number} height
  * @param {{ innerRadius?: number }} opts
  * @param {Map<unknown, string>} [patterns]
- * @returns {{ d: string | null, fill: string, stroke: string, key: unknown, patternId: string | null, pct: number, centroid: [number, number], data: Record<string, unknown> }[]}
+ * `key` is the slice's category — what picks its colour and pattern — so it repeats when rows
+ * share a category, and is undefined without a colour field. `id` is unique per slice (the key
+ * plus its occurrence), for keyed rendering; stable across updates while categories are unique.
+ *
+ * @returns {{ id: string, d: string | null, fill: string, stroke: string, key: unknown, patternId: string | null, pct: number, centroid: [number, number], data: Record<string, unknown> }[]}
  */
 export function buildArcs(data, channels, colors, width, height, opts = {}, patterns) {
 	const { color: lf, y: yf } = channels
@@ -32,6 +36,7 @@ export function buildArcs(data, channels, colors, width, height, opts = {}, patt
 	// Label radius: midpoint between inner and outer (or 70% out for solid pie)
 	const labelRadius = innerRadius > 0 ? (innerRadius + radius) / 2 : radius * 0.65
 	const labelArc = arc().innerRadius(labelRadius).outerRadius(labelRadius)
+	const seen = new Map()
 	return slices.map((slice, i) => {
 		// With a literal color there's no category field, so key each slice by index to keep
 		// them distinct (patterns, which are field-keyed, don't apply to a single literal fill).
@@ -41,7 +46,10 @@ export function buildArcs(data, channels, colors, width, height, opts = {}, patt
 			!lit && key !== null && key !== undefined && patterns?.has(key) ? toPatternId(String(key)) : null
 		const pct = Math.round(((slice.endAngle - slice.startAngle) / total) * 100)
 		const [cx, cy] = labelArc.centroid(slice)
+		const occurrence = seen.get(key) ?? 0
+		seen.set(key, occurrence + 1)
 		return {
+			id: `${String(key)}#${occurrence}`,
 			d: arcGen(slice),
 			fill: colorEntry.fill,
 			stroke: colorEntry.stroke,

package/dist/lib/brewing/polar.js

@@ -43,11 +43,15 @@
  * Fills in the derived fields shared by every axis, regardless of which of the two
  * accepted shorthand forms it started from.
  *
- * @param {string|AxisSpec} entry
+ * Only an object is an AxisSpec; any other value — a string, or a number / boolean category
+ * read from the data — is the axis key itself. (Treating every non-string as a spec spread a
+ * numeric category into `{}`, keying every numeric axis `undefined`.)
+ *
+ * @param {string|number|AxisSpec} entry
  * @returns {ResolvedAxis}
  */
 function normaliseAxis(entry) {
-	const spec = typeof entry === 'string' ? { key: entry } : entry
+	const spec = typeof entry === 'object' ? entry : { key: entry }
 	const label = spec.label ?? spec.key
 	return {
 		...spec,
@@ -101,7 +105,8 @@ function axisKeysInData(data, axisField) {
 	const seen = new Set()
 	for (const row of data) {
 		const key = row?.[axisField]
-		if (key !== undefined) seen.add(key)
+		// A missing category — undefined or null — names no axis.
+		if (key !== undefined && key !== null) seen.add(key)
 	}
 	return [...seen]
 }

package/dist/lib/hull.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Hull vertices, counter-clockwise in a y-up frame, starting from the lowest-x point.
+ * Collinear edge points are dropped; duplicates collapse; one or two distinct points come
+ * back as-is (a dot, a segment).
+ *
+ * @param {Pt[]} points
+ * @returns {Pt[]}
+ */
+export function convexHull(points: Pt[]): Pt[];
+/**
+ * Closed SVG path through hull vertices. One vertex is a zero-length subpath and two are a
+ * segment — with a round cap and a wide stroke those render as a dot and a capsule, which is
+ * how `Hull` pads every group, whatever its size, with one element.
+ *
+ * @param {Pt[]} hull
+ */
+export function hullPath(hull: Pt[]): string;
+export type Pt = [number, number];

package/dist/lib/hull.js

@@ -0,0 +1,64 @@
+/**
+ * Convex hull (Andrew's monotone chain), O(n log n), and its SVG path.
+ *
+ * Hand-rolled rather than `d3-polygon` because the degenerate cases matter here and d3 returns
+ * null for them: a group with one or two members is still a group, and an outline that
+ * silently disappears for a small package is the same lie as an edge that disappears for an
+ * unresolved call.
+ */
+
+/** @typedef {[number, number]} Pt */
+
+/** z of (b - a) × (c - a): > 0 is a left (counter-clockwise) turn. */
+const cross = (/** @type {Pt} */ a, /** @type {Pt} */ b, /** @type {Pt} */ c) =>
+	(b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0])
+
+/**
+ * Hull vertices, counter-clockwise in a y-up frame, starting from the lowest-x point.
+ * Collinear edge points are dropped; duplicates collapse; one or two distinct points come
+ * back as-is (a dot, a segment).
+ *
+ * @param {Pt[]} points
+ * @returns {Pt[]}
+ */
+export function convexHull(points) {
+	const seen = new Set()
+	const pts = []
+	for (const p of points) {
+		const key = `${p[0]},${p[1]}`
+		if (!seen.has(key)) {
+			seen.add(key)
+			pts.push(p)
+		}
+	}
+	pts.sort((a, b) => a[0] - b[0] || a[1] - b[1])
+	if (pts.length < 3) return pts
+
+	/** @param {Pt[]} seq */
+	const chain = (seq) => {
+		/** @type {Pt[]} */
+		const out = []
+		for (const p of seq) {
+			while (out.length >= 2 && cross(out[out.length - 2], out[out.length - 1], p) <= 0) out.pop()
+			out.push(p)
+		}
+		out.pop()
+		return out
+	}
+	const hull = [...chain(pts), ...chain([...pts].reverse())]
+	// All points collinear: both chains collapse to the two extremes.
+	return hull.length < 2 ? [pts[0], pts[pts.length - 1]] : hull
+}
+
+/**
+ * Closed SVG path through hull vertices. One vertex is a zero-length subpath and two are a
+ * segment — with a round cap and a wide stroke those render as a dot and a capsule, which is
+ * how `Hull` pads every group, whatever its size, with one element.
+ *
+ * @param {Pt[]} hull
+ */
+export function hullPath(hull) {
+	if (hull.length === 0) return ''
+	const fmt = (/** @type {number} */ n) => Math.round(n * 1000) / 1000
+	return `M${hull.map(([x, y]) => `${fmt(x)},${fmt(y)}`).join('L')}Z`
+}

package/dist/lib/plot/domains.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Band categories ordered by their summed value — "sort bars by size". Null when not sorting.
+ *
+ * @param {Record<string, unknown>[][]} datasets - every geom's rows
+ * @param {string | undefined} xf
+ * @param {string | undefined} yf
+ * @param {'asc' | 'desc' | undefined} sort
+ */
+export function sortedBandDomain(datasets: Record<string, unknown>[][], xf: string | undefined, yf: string | undefined, sort: "asc" | "desc" | undefined): any[] | null;
+/**
+ * A box/violin spans its whiskers (`iqr_min` / `iqr_max`) and every outlier.
+ *
+ * @param {Record<string, any>[]} rows - box-stat rows
+ */
+export function boxDomain(rows: Record<string, any>[]): number[] | null;
+/**
+ * A stacked bar reaches its column total; a 100%-filled one reaches 1.
+ *
+ * Summed per (x, stack key), keeping the LAST value per key — the builder's own lookup does the
+ * same, so rows sharing a key under an identity stat do not double-count. The stack key is the
+ * builder's (`stackFieldOf`); with none, the builder draws plain bars, so there is no total to
+ * size to and the normal extent applies (null).
+ *
+ * @param {Record<string, unknown>[]} rows
+ * @param {{ x?: string, y?: string, group?: string, fill?: string, color?: string, pattern?: string }} channels
+ * @param {'stack' | 'fill' | undefined} position
+ */
+export function stackDomain(rows: Record<string, unknown>[], channels: {
+    x?: string;
+    y?: string;
+    group?: string;
+    fill?: string;
+    color?: string;
+    pattern?: string;
+}, position: "stack" | "fill" | undefined): number[] | null;
+/**
+ * A waterfall spans its running total: each step from where the last ended, a total row from 0.
+ *
+ * @param {Record<string, unknown>[]} rows
+ * @param {string} field
+ * @param {string} [totalField] - rows flagged here are totals, drawn from zero
+ */
+export function waterfallDomain(rows: Record<string, unknown>[], field: string, totalField?: string): number[] | null;
+/**
+ * The value-axis domain the mounted geoms' geometry demands, or null for the plain extent.
+ *
+ * @param {Array<{ id: string, type: string, options?: Record<string, any> }>} geoms
+ * @param {(id: string) => Record<string, unknown>[]} rowsOf - a geom's rows (post-stat)
+ * @param {{ x?: string, fill?: string, color?: string, pattern?: string }} channels - effective
+ * @param {string} field - the value channel
+ */
+export function resolveValueDomain(geoms: Array<{
+    id: string;
+    type: string;
+    options?: Record<string, any>;
+}>, rowsOf: (id: string) => Record<string, unknown>[], channels: {
+    x?: string;
+    fill?: string;
+    color?: string;
+    pattern?: string;
+}, field: string): number[] | null;

package/dist/lib/plot/domains.js

@@ -0,0 +1,130 @@
+/**
+ * Axis domains that a geom's own geometry decides, rather than the raw extent of its rows.
+ *
+ * A box spans its whiskers and outliers, not its rows' y; a stacked bar reaches its column
+ * TOTAL; a waterfall bar sits on a running total. Pure functions over the rows a geom draws,
+ * so they are testable without Svelte, and `resolveValueDomain` asks them in a fixed order —
+ * a new geom with a geometry-driven domain adds a row to that table instead of editing the
+ * scale code.
+ */
+import { stackFieldOf } from './stacking.js'
+import { runningSpans } from './running.js'
+
+const valid = (v) => v !== null && v !== undefined && !isNaN(v)
+
+/**
+ * Band categories ordered by their summed value — "sort bars by size". Null when not sorting.
+ *
+ * @param {Record<string, unknown>[][]} datasets - every geom's rows
+ * @param {string | undefined} xf
+ * @param {string | undefined} yf
+ * @param {'asc' | 'desc' | undefined} sort
+ */
+export function sortedBandDomain(datasets, xf, yf, sort) {
+	if (!sort || !xf || !yf) return null
+	// A Map, not an object: keys are raw values (numbers, Dates) an object would stringify.
+	const totals = new Map()
+	for (const rows of datasets) {
+		for (const d of rows) totals.set(d[xf], (totals.get(d[xf]) ?? 0) + (Number(d[yf]) || 0))
+	}
+	const dir = sort === 'asc' ? 1 : -1
+	return [...totals.keys()].sort((a, b) => dir * (totals.get(a) - totals.get(b)))
+}
+
+/**
+ * A box/violin spans its whiskers (`iqr_min` / `iqr_max`) and every outlier.
+ *
+ * @param {Record<string, any>[]} rows - box-stat rows
+ */
+export function boxDomain(rows) {
+	const outliers = rows.flatMap((d) => d.outliers ?? []).filter(valid)
+	const mins = [...rows.map((d) => d.iqr_min).filter(valid), ...outliers]
+	const maxs = [...rows.map((d) => d.iqr_max).filter(valid), ...outliers]
+	return mins.length > 0 && maxs.length > 0 ? [Math.min(...mins), Math.max(...maxs)] : null
+}
+
+/**
+ * A stacked bar reaches its column total; a 100%-filled one reaches 1.
+ *
+ * Summed per (x, stack key), keeping the LAST value per key — the builder's own lookup does the
+ * same, so rows sharing a key under an identity stat do not double-count. The stack key is the
+ * builder's (`stackFieldOf`); with none, the builder draws plain bars, so there is no total to
+ * size to and the normal extent applies (null).
+ *
+ * @param {Record<string, unknown>[]} rows
+ * @param {{ x?: string, y?: string, group?: string, fill?: string, color?: string, pattern?: string }} channels
+ * @param {'stack' | 'fill' | undefined} position
+ */
+export function stackDomain(rows, channels, position) {
+	if (position === 'fill') return [0, 1]
+	const stackField = stackFieldOf(channels)
+	if (!channels.x || rows.length === 0 || !stackField) return null
+	const columns = new Map()
+	for (const d of rows) {
+		const column = columns.get(d[channels.x]) ?? new Map()
+		column.set(String(d[stackField]), Number(d[channels.y]) || 0)
+		columns.set(d[channels.x], column)
+	}
+	const totals = [...columns.values()].map((c) => [...c.values()].reduce((s, v) => s + v, 0))
+	return [0, Math.max(0, ...totals)]
+}
+
+/**
+ * A waterfall spans its running total: each step from where the last ended, a total row from 0.
+ *
+ * @param {Record<string, unknown>[]} rows
+ * @param {string} field
+ * @param {string} [totalField] - rows flagged here are totals, drawn from zero
+ */
+export function waterfallDomain(rows, field, totalField) {
+	if (rows.length === 0) return null
+	const spans = runningSpans(rows, field, totalField)
+	return [Math.min(0, ...spans.map((s) => s.lo)), Math.max(0, ...spans.map((s) => s.hi))]
+}
+
+/** A geom's channels without the keys it left undefined (to inherit). */
+const definedOf = (channels = {}) =>
+	Object.fromEntries(Object.entries(channels).filter(([, v]) => v !== undefined))
+
+const isStacked = (g) =>
+	g.options?.stack || g.options?.position === 'stack' || g.options?.position === 'fill'
+
+/**
+ * Geom types whose geometry decides the VALUE axis, asked in order; the first to return a
+ * domain wins. Each resolver reads the first mounted geom it matches.
+ */
+const VALUE_DOMAINS = [
+	{ matches: (g) => g.type === 'box' || g.type === 'violin', domain: (rows) => boxDomain(rows) },
+	{
+		matches: isStacked,
+		// The geom's OWN channels win — `group` exists only there — over the effective ones.
+		domain: (rows, geom, channels, field) =>
+			stackDomain(
+				rows,
+				{ ...channels, ...definedOf(geom.channels), y: field },
+				geom.options?.position === 'fill' ? 'fill' : 'stack'
+			)
+	},
+	{
+		matches: (g) => g.type === 'waterfall',
+		domain: (rows, geom, _channels, field) => waterfallDomain(rows, field, geom.options?.totalField)
+	}
+]
+
+/**
+ * The value-axis domain the mounted geoms' geometry demands, or null for the plain extent.
+ *
+ * @param {Array<{ id: string, type: string, options?: Record<string, any> }>} geoms
+ * @param {(id: string) => Record<string, unknown>[]} rowsOf - a geom's rows (post-stat)
+ * @param {{ x?: string, fill?: string, color?: string, pattern?: string }} channels - effective
+ * @param {string} field - the value channel
+ */
+export function resolveValueDomain(geoms, rowsOf, channels, field) {
+	for (const resolver of VALUE_DOMAINS) {
+		const geom = geoms.find(resolver.matches)
+		if (!geom) continue
+		const domain = resolver.domain(rowsOf(geom.id), geom, channels, field)
+		if (domain) return domain
+	}
+	return null
+}

package/dist/lib/plot/running.d.ts

@@ -0,0 +1,23 @@
+/**
+ * A waterfall's geometry: where each bar starts and ends on the value axis.
+ *
+ * One function for the builder that draws the bars and the domain that sizes the axis to them —
+ * two copies disagreed: the builder drew a negative total as a 1px sliver at zero, and let a
+ * missing value turn every later bar into NaN, while the axis was sized as if neither happened.
+ *
+ * A step runs from the running total before it to the running total after; a total row (flagged
+ * by `totalField`) runs from 0 to the running total, in whichever direction that is. A missing
+ * or non-numeric value is a step of 0.
+ *
+ * @param {Record<string, unknown>[]} rows
+ * @param {string} field
+ * @param {string} [totalField]
+ * @returns {Array<{ lo: number, hi: number, total: number, isTotal: boolean, delta: number }>}
+ */
+export function runningSpans(rows: Record<string, unknown>[], field: string, totalField?: string): Array<{
+    lo: number;
+    hi: number;
+    total: number;
+    isTotal: boolean;
+    delta: number;
+}>;

package/dist/lib/plot/running.js

@@ -0,0 +1,32 @@
+/**
+ * A waterfall's geometry: where each bar starts and ends on the value axis.
+ *
+ * One function for the builder that draws the bars and the domain that sizes the axis to them —
+ * two copies disagreed: the builder drew a negative total as a 1px sliver at zero, and let a
+ * missing value turn every later bar into NaN, while the axis was sized as if neither happened.
+ *
+ * A step runs from the running total before it to the running total after; a total row (flagged
+ * by `totalField`) runs from 0 to the running total, in whichever direction that is. A missing
+ * or non-numeric value is a step of 0.
+ *
+ * @param {Record<string, unknown>[]} rows
+ * @param {string} field
+ * @param {string} [totalField]
+ * @returns {Array<{ lo: number, hi: number, total: number, isTotal: boolean, delta: number }>}
+ */
+export function runningSpans(rows, field, totalField) {
+	let running = 0
+	return rows.map((d) => {
+		const isTotal = Boolean(totalField && d[totalField])
+		const delta = isTotal ? 0 : Number(d[field]) || 0
+		const start = isTotal ? 0 : running
+		running += delta
+		return {
+			lo: Math.min(start, running),
+			hi: Math.max(start, running),
+			total: running,
+			isTotal,
+			delta
+		}
+	})
+}

package/dist/lib/plot/spec.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The config `PlotSurface` builds its `PlotState` from.
+ *
+ * @param {Record<string, any> | undefined} spec
+ * @param {Record<string, any>} props - the component's props
+ * @param {unknown} chartPreset - the resolved preset (context, else the default)
+ */
+export function resolvePlotConfig(spec: Record<string, any> | undefined, props: Record<string, any>, chartPreset: unknown): {
+    [k: string]: any;
+};
+/**
+ * The chrome around the marks: grid, legend, title, summary, axis labels, and the fields the
+ * trend / highlight overlays draw on.
+ *
+ * `grid`: `false` hides it; `true` is 'auto'; `'x' | 'y' | 'both'` names the lines.
+ *
+ * @param {Record<string, any> | undefined} spec
+ * @param {Record<string, any>} props
+ */
+export function resolveChrome(spec: Record<string, any> | undefined, props: Record<string, any>): {
+    showGrid: boolean;
+    gridLines: any;
+    showLegend: any;
+    title: any;
+    summary: any;
+    overlayX: any;
+    overlayY: any;
+    xLabel: any;
+    yLabel: any;
+};
+/**
+ * The accessible table's columns: the spec's channels (deduped — a table's keyed each needs
+ * unique names, and `x === color` is normal), else the first row's keys.
+ *
+ * @param {Record<string, any> | undefined} spec
+ * @param {Record<string, unknown>[]} rows
+ * @returns {string[]}
+ */
+export function tableColumns(spec: Record<string, any> | undefined, rows: Record<string, unknown>[]): string[];
+/**
+ * The props for one `spec.geoms` entry: the spec's channels unless the geom names its own,
+ * the spec's stack / orientation under the geom's options, and the geom's `props` over all.
+ *
+ * @param {Record<string, any>} geomSpec
+ * @param {Record<string, any> | undefined} spec
+ */
+export function specGeomProps(geomSpec: Record<string, any>, spec: Record<string, any> | undefined): any;
+/**
+ * The PlotState config fields read straight from spec and/or props, in config order.
+ * @type {Array<[string, keyof typeof SOURCES]>}
+ */
+export const PLOT_CONFIG_FIELDS: Array<[string, keyof typeof SOURCES]>;
+declare namespace SOURCES {
+    function spec(key: any, spec: any): any;
+    function prop(key: any, _spec: any, props: any): any;
+    function specFirst(key: any, spec: any, props: any): any;
+    function propFirst(key: any, spec: any, props: any): any;
+}
+export {};