@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/bars/ButterflyChart.js

@@ -0,0 +1,85 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { MirrorChart, MirrorMark } from "./MirrorChart.js";
+import { descending, max } from "d3";
+// src/charts/bars/ButterflyChart.ts
+var ButterflyChartSort = /* @__PURE__ */ function(ButterflyChartSort) {
+	ButterflyChartSort["Data"] = "data";
+	ButterflyChartSort["Left"] = "left";
+	ButterflyChartSort["Right"] = "right";
+	ButterflyChartSort["Total"] = "total";
+	ButterflyChartSort["Gap"] = "gap";
+	return ButterflyChartSort;
+}({});
+var ButterflyChartScale = /* @__PURE__ */ function(ButterflyChartScale) {
+	ButterflyChartScale["Shared"] = "shared";
+	ButterflyChartScale["Independent"] = "independent";
+	return ButterflyChartScale;
+}({});
+/** Back-to-back comparison of two groups; sort by total or gap for a tornado sensitivity view. */
+var ButterflyChart = class extends MirrorChart {
+	static meta = {
+		id: "bar-butterfly",
+		name: "Butterfly chart",
+		family: ChartFamily.Comparison,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Mirrors two groups around a central spine, and sorts into a tornado to rank the widest effects.",
+		tags: [
+			"tornado",
+			"back to back",
+			"mirror",
+			"sensitivity"
+		],
+		sample: (seed) => SampleData.categories(seed, 9, 2).map((row) => row.series === "Bravo" ? {
+			...row,
+			value: Math.round(+row.value * .6)
+		} : row),
+		variants: {
+			gutter: [true, false],
+			sort: [
+				"data",
+				"total",
+				"gap",
+				"left",
+				"right"
+			],
+			mark: [
+				MirrorMark.Bar,
+				MirrorMark.Lollipop,
+				MirrorMark.Silhouette
+			],
+			scale: ["shared", "independent"],
+			labels: [false, true]
+		}
+	};
+	defaults() {
+		return {
+			x: "category",
+			y: "value",
+			series: "series",
+			gutter: true,
+			sort: "data",
+			mark: MirrorMark.Bar,
+			scale: "shared",
+			labels: false,
+			padding: .15
+		};
+	}
+	rows() {
+		const rows = this.pivoted();
+		const by = {
+			["data"]: null,
+			["left"]: (row) => row.left,
+			["right"]: (row) => row.right,
+			["total"]: (row) => row.left + row.right,
+			["gap"]: (row) => Math.abs(row.left - row.right)
+		}[this.options.sort];
+		return by ? rows.sort((a, b) => descending(by(a), by(b))) : rows;
+	}
+	domains(rows) {
+		if (this.options.scale === "shared") return super.domains(rows);
+		return [max(rows, (row) => row.left) || 1, max(rows, (row) => row.right) || 1];
+	}
+};
+export { ButterflyChart, ButterflyChartScale, ButterflyChartSort };

package/dist/charts/bars/DateBarChart.js

@@ -0,0 +1,149 @@
+import { CartesianChart } from "../../core/CartesianChart.js";
+import { ChartFamily, DataShape, Dimension, StackMode } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { BarFrame } from "./BarFrame.js";
+import { BarAggregate, BarRows } from "./BarRows.js";
+import { max, scaleLinear, scaleUtc, sum, utcDay, utcFormat, utcMonday, utcMonth } from "d3";
+// src/charts/bars/DateBarChart.ts
+var DateBarInterval = /* @__PURE__ */ function(DateBarInterval) {
+	DateBarInterval["Day"] = "day";
+	DateBarInterval["Week"] = "week";
+	DateBarInterval["Month"] = "month";
+	return DateBarInterval;
+}({});
+var INTERVALS = {
+	["day"]: utcDay,
+	["week"]: utcMonday,
+	["month"]: utcMonth
+};
+/** Bars on a true calendar axis: each bar spans its period, so uneven months and gaps stay honest. */
+var DateBarChart = class extends CartesianChart {
+	static meta = {
+		id: "bar-date",
+		name: "Date bar chart",
+		family: ChartFamily.Temporal,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Buckets dated rows into days, weeks or months and draws each bar across its real span of the calendar.",
+		tags: [
+			"time",
+			"calendar",
+			"column",
+			"volume"
+		],
+		sample: (seed) => SampleData.timeSeries(seed, 90, 3),
+		variants: {
+			interval: [
+				"week",
+				"day",
+				"month"
+			],
+			stack: [
+				StackMode.Stacked,
+				StackMode.Normalized,
+				StackMode.None
+			],
+			aggregate: [
+				BarAggregate.Sum,
+				BarAggregate.Mean,
+				BarAggregate.Max
+			]
+		},
+		valid: (values) => (values.interval !== "day" || values.aggregate === BarAggregate.Sum && values.stack !== StackMode.None) && !(values.stack === StackMode.Normalized && values.aggregate === BarAggregate.Mean)
+	};
+	defaults() {
+		return {
+			x: "date",
+			y: "value",
+			series: "series",
+			interval: "week",
+			stack: StackMode.Stacked,
+			aggregate: BarAggregate.Sum
+		};
+	}
+	buckets() {
+		const { data, x, y, series, interval, stack, aggregate } = this.options;
+		const floor = INTERVALS[interval];
+		const cells = /* @__PURE__ */ new Map();
+		const names = /* @__PURE__ */ new Set();
+		for (const row of data ?? []) {
+			const cell = row[x], value = BarRows.number(row[y]);
+			const date = cell instanceof Date ? cell : cell === null || cell === void 0 ? null : new Date(cell);
+			if (!date || Number.isNaN(+date) || value === null) continue;
+			const name = BarRows.label(row[series] ?? "All");
+			names.add(name);
+			const key = +floor(date);
+			const bucket = cells.get(key) ?? /* @__PURE__ */ new Map();
+			bucket.set(name, [...bucket.get(name) ?? [], value]);
+			cells.set(key, bucket);
+		}
+		const list = [...names];
+		const keys = [...cells.keys()].sort((a, b) => a - b);
+		const buckets = keys.flatMap((key) => {
+			const time = new Date(key), next = floor.offset(time, 1);
+			const reduced = list.map((name) => {
+				const values = cells.get(key).get(name);
+				return values ? Math.max(0, BarRows.reduce(values, aggregate)) : 0;
+			});
+			const scale = stack === StackMode.Normalized ? 100 / (sum(reduced) || 1) : 1;
+			let cursor = 0;
+			return list.map((name, slot) => {
+				const size = reduced[slot] * scale;
+				const start = stack === StackMode.None ? 0 : cursor;
+				cursor += size;
+				return {
+					time,
+					next,
+					series: name,
+					slot,
+					value: reduced[slot],
+					start,
+					end: start + size,
+					outer: stack === StackMode.None || slot === list.length - 1
+				};
+			});
+		});
+		const first = keys[0] ?? Date.UTC(2026, 0, 1);
+		return {
+			buckets,
+			series: list,
+			start: new Date(first),
+			end: floor.offset(new Date(keys[keys.length - 1] ?? first), 1)
+		};
+	}
+	scales(ctx) {
+		const { buckets, start, end } = this.buckets();
+		const normal = this.options.stack === StackMode.Normalized;
+		const x = scaleUtc([start, end], [0, ctx.plot.width]);
+		const y = scaleLinear([0, normal ? 100 : max(buckets, (bucket) => bucket.end) || 1], [ctx.plot.height, 0]);
+		return {
+			x,
+			y: normal ? y : y.nice()
+		};
+	}
+	tickFormat(scale) {
+		const format = super.tickFormat(scale);
+		return format && this.options.stack === StackMode.Normalized ? (value) => `${format(value)}%` : format;
+	}
+	plotMarks(ctx, axes) {
+		const time = axes.x;
+		const count = axes.y;
+		const { buckets, series } = this.buckets();
+		const grouped = this.options.stack === StackMode.None;
+		const slots = grouped ? Math.max(1, series.length) : 1;
+		const frame = new BarFrame(true, count);
+		const size = (d) => (time(d.next) - time(d.time)) / slots;
+		const width = (d) => Math.max(1, size(d) - (size(d) > 3 ? 2 : .5));
+		const at = (d) => time(d.time) + (grouped ? d.slot * size(d) : 0);
+		const shape = (d, to) => frame.bar(at(d), width(d), d.start, to, d.outer ? 3 : 0, d.start ? 1 : 0);
+		const bars = ctx.marks("bars", "path", buckets, (d) => `${+d.time}/${d.series}`).attr("fill", (d) => ctx.palette.color(d.series));
+		ctx.set(bars, { d: (d) => shape(d, d.end) }, { d: (d) => shape(d, d.start) }, 2);
+		const label = utcFormat(this.options.interval === "month" ? "%b %Y" : "%b %-d, %Y");
+		ctx.hover(bars, (d) => ({
+			title: label(d.time),
+			color: ctx.palette.color(d.series),
+			rows: [[d.series, +d.value.toFixed(2)]]
+		}));
+	}
+};
+export { DateBarChart, DateBarInterval };

package/dist/charts/bars/DivergingBarChart.js

@@ -0,0 +1,226 @@
+import { ChartFamily, DataShape, Dimension, Orientation } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { BandChart } from "./BandChart.js";
+import { BarRows, BarSort } from "./BarRows.js";
+import { max, mean, median, sum } from "d3";
+// src/charts/bars/DivergingBarChart.ts
+var DivergingBarLayout = /* @__PURE__ */ function(DivergingBarLayout) {
+	DivergingBarLayout["Net"] = "net";
+	DivergingBarLayout["Stacked"] = "stacked";
+	DivergingBarLayout["Likert"] = "likert";
+	return DivergingBarLayout;
+}({});
+var DivergingBarCenter = /* @__PURE__ */ function(DivergingBarCenter) {
+	DivergingBarCenter["Zero"] = "zero";
+	DivergingBarCenter["Mean"] = "mean";
+	DivergingBarCenter["Median"] = "median";
+	return DivergingBarCenter;
+}({});
+var DivergingBarLabels = /* @__PURE__ */ function(DivergingBarLabels) {
+	DivergingBarLabels["Axis"] = "axis";
+	DivergingBarLabels["Opposite"] = "opposite";
+	return DivergingBarLabels;
+}({});
+/** Show values above and below a neutral point: net sentiment, signed stacks or centred Likert scales. */
+var DivergingBarChart = class extends BandChart {
+	static meta = {
+		id: "bar-diverging",
+		name: "Diverging bar chart",
+		family: ChartFamily.Comparison,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Splits bars at a neutral centre so direction and size read together, including centred Likert stacks.",
+		tags: [
+			"deviation",
+			"likert",
+			"sentiment",
+			"net"
+		],
+		sample: (seed) => SampleData.categories(seed, 7, 5).map((row) => ({
+			...row,
+			value: +row.value - 68
+		})),
+		variants: {
+			orientation: [Orientation.Horizontal, Orientation.Vertical],
+			layout: [
+				"net",
+				"stacked",
+				"likert"
+			],
+			sort: [
+				BarSort.Data,
+				BarSort.Descending,
+				BarSort.Ascending
+			],
+			center: [
+				"zero",
+				"mean",
+				"median"
+			],
+			labelPlacement: ["axis", "opposite"]
+		},
+		valid: (values) => values.layout === "net" || values.center === "zero" && values.labelPlacement === "axis"
+	};
+	defaults() {
+		return {
+			x: "category",
+			y: "value",
+			series: "series",
+			orientation: Orientation.Horizontal,
+			layout: "net",
+			sort: BarSort.Data,
+			center: "zero",
+			labelPlacement: "axis"
+		};
+	}
+	get pivot() {
+		return BarRows.pivot(this.options.data, this.options.x, this.options.series, this.options.y);
+	}
+	get opposite() {
+		return this.options.labelPlacement === "opposite";
+	}
+	pieces() {
+		const { layout } = this.options;
+		if (layout === "likert") return this.likert();
+		return layout === "stacked" ? this.stacked() : this.net();
+	}
+	net() {
+		const { pivot } = this;
+		const { center, sort, y } = this.options;
+		const totals = pivot.bands.map((band) => pivot.total(band));
+		const shift = center === "mean" ? mean(totals) ?? 0 : center === "median" ? median(totals) ?? 0 : 0;
+		const rows = pivot.bands.map((band, i) => ({
+			band,
+			value: totals[i] - shift
+		}));
+		return BarRows.order(rows, sort, (row) => row.value, (row) => row.band).map(({ band, value }) => ({
+			band,
+			series: y,
+			value,
+			start: 0,
+			end: value,
+			outer: true,
+			tone: value < 0 ? -.9 : .9
+		}));
+	}
+	stacked() {
+		const { pivot } = this;
+		return BarRows.order(pivot.bands, this.options.sort, pivot.total, (band) => band).flatMap((band) => {
+			const cells = pivot.series.map((series) => ({
+				series,
+				value: pivot.cell(band, series)
+			}));
+			const lastUp = cells.findLast((cell) => cell.value > 0)?.series, lastDown = cells.findLast((cell) => cell.value < 0)?.series;
+			let up = 0, down = 0;
+			return cells.map(({ series, value }) => {
+				const start = value < 0 ? down : up;
+				if (value < 0) down += value;
+				else up += value;
+				return {
+					band,
+					series,
+					value,
+					start,
+					end: start + value,
+					outer: series === lastUp || series === lastDown,
+					tone: 0
+				};
+			});
+		});
+	}
+	likert() {
+		const { pivot } = this;
+		const steps = pivot.series.length, middle = (steps - 1) / 2;
+		const shares = (band) => {
+			const cells = pivot.series.map((series) => Math.abs(pivot.cell(band, series)));
+			const total = sum(cells) || 1;
+			return cells.map((cell) => cell / total * 100);
+		};
+		const lean = (band) => sum(shares(band), (share, i) => share * Math.sign(i - middle));
+		return BarRows.order(pivot.bands, this.options.sort, lean, (band) => band).flatMap((band) => {
+			const parts = shares(band);
+			let cursor = -sum(parts.filter((_, i) => i < middle)) - (steps % 2 ? parts[Math.floor(middle)] / 2 : 0);
+			return pivot.series.map((series, i) => {
+				const start = cursor;
+				cursor += parts[i];
+				return {
+					band,
+					series,
+					value: parts[i],
+					start,
+					end: cursor,
+					outer: i === 0 || i === steps - 1,
+					tone: middle ? (i - middle) / middle : 0
+				};
+			});
+		});
+	}
+	bandNames() {
+		return [...new Set(this.pieces().map((piece) => piece.band))];
+	}
+	bandPadding() {
+		return this.options.layout === "net" ? .2 : .18;
+	}
+	unit() {
+		return this.options.layout === "likert" ? "%" : "";
+	}
+	valueExtent() {
+		const edges = this.pieces().flatMap((piece) => [piece.start, piece.end]);
+		const reach = max(edges, Math.abs) ?? 1;
+		return this.opposite || this.options.layout === "likert" ? [-reach, reach] : [Math.min(0, ...edges), Math.max(0, ...edges)];
+	}
+	tickFormat(scale) {
+		const format = super.tickFormat(scale);
+		if (this.opposite && typeof (scale.domain?.())[0] === "string") return () => "";
+		return typeof (scale.domain?.())[0] === "number" && format && this.options.layout === "likert" ? (value) => format(Math.abs(+value)) : format;
+	}
+	legendItems() {
+		if (this.options.layout === "stacked") return this.palette.items();
+		if (this.options.layout === "net") return [{
+			key: "Below",
+			color: this.palette.diverging(-.9)
+		}, {
+			key: "Above",
+			color: this.palette.diverging(.9)
+		}];
+		return this.pivot.series.map((key, i, all) => ({
+			key,
+			color: this.likertTone(all.length > 1 ? (i - (all.length - 1) / 2) / ((all.length - 1) / 2) : 0)
+		}));
+	}
+	likertTone(tone) {
+		return tone === 0 ? this.theme.axis : this.palette.diverging(tone);
+	}
+	drawBands(ctx, frame) {
+		const parts = this.pieces();
+		const { layout } = this.options;
+		const fill = (d) => layout === "stacked" ? ctx.palette.color(d.series) : layout === "likert" ? this.likertTone(d.tone) : ctx.palette.diverging(d.tone);
+		const flush = layout === "likert" ? (d) => d.start !== parts.find((part) => part.band === d.band).start : (d) => d.start !== 0;
+		const shape = (d, to) => frame.bar(frame.band(d.band) ?? 0, frame.thick, d.start, to, d.outer ? 4 : 0, flush(d) ? 2 : 0);
+		const bars = ctx.marks("bars", "path", parts, (d) => `${d.band}/${d.series}`).attr("fill", fill);
+		ctx.set(bars, { d: (d) => shape(d, d.end) }, { d: (d) => shape(d, d.start) }, 10);
+		ctx.hover(bars, (d) => ({
+			title: d.band,
+			color: fill(d),
+			rows: [[d.series, +d.value.toFixed(2)]]
+		}));
+		this.drawOpposite(ctx, frame, parts);
+	}
+	/** Band names sit across the centre from each bar, so they never collide with it. */
+	drawOpposite(ctx, frame, parts) {
+		const leaning = (band) => sum(parts.filter((part) => part.band === band), (part) => part.start + part.end);
+		const names = this.opposite ? [...new Set(parts.map((part) => part.band))] : [];
+		const every = frame.vertical ? Math.max(1, Math.ceil(50 / (frame.band.step() || 1))) : Math.max(1, Math.ceil(12 / (frame.band.step() || 1)));
+		const kept = names.filter((_, i) => i % every === 0).map((band) => ({
+			band,
+			up: leaning(band) >= 0
+		}));
+		const lift = (d) => frame.vertical ? d.up ? 13 : -5 : d.up ? -6 : 6;
+		const labels = ctx.text(ctx.marks("opposite", "text", kept, (d) => d.band), 10.5).text((d) => BarRows.clip(d.band, 14)).attr("text-anchor", frame.vertical ? "middle" : (d) => d.up ? "end" : "start").style("pointer-events", "none");
+		ctx.set(labels, {
+			x: (d) => frame.point(frame.center(d.band), 0, lift(d))[0],
+			y: (d) => frame.point(frame.center(d.band) + (frame.vertical ? 0 : 3.5), 0, lift(d))[1]
+		});
+	}
+};
+export { DivergingBarCenter, DivergingBarChart, DivergingBarLabels, DivergingBarLayout };

package/dist/charts/bars/DotPlot.js

@@ -0,0 +1,167 @@
+import { ChartFamily, DataShape, Dimension, Orientation, SymbolKind } from "../../core/enums.js";
+import { Scales } from "../../core/Scales.js";
+import { SampleData } from "../../data/SampleData.js";
+import { BandChart } from "./BandChart.js";
+import { BarRows, BarSort } from "./BarRows.js";
+import { extent, group, max, min, scaleLog, symbol } from "d3";
+// src/charts/bars/DotPlot.ts
+var DotPlotGuide = /* @__PURE__ */ function(DotPlotGuide) {
+	DotPlotGuide["Line"] = "line";
+	DotPlotGuide["Range"] = "range";
+	DotPlotGuide["None"] = "none";
+	return DotPlotGuide;
+}({});
+var DotPlotLayout = /* @__PURE__ */ function(DotPlotLayout) {
+	DotPlotLayout["Overlaid"] = "overlaid";
+	DotPlotLayout["Dodged"] = "dodged";
+	return DotPlotLayout;
+}({});
+var DotPlotDomain = /* @__PURE__ */ function(DotPlotDomain) {
+	DotPlotDomain["Tight"] = "tight";
+	DotPlotDomain["Zero"] = "zero";
+	DotPlotDomain["Log"] = "log";
+	return DotPlotDomain;
+}({});
+var SHAPES = [
+	SymbolKind.Circle,
+	SymbolKind.Square,
+	SymbolKind.Diamond,
+	SymbolKind.Triangle,
+	SymbolKind.Wye,
+	SymbolKind.Cross,
+	SymbolKind.Star
+];
+/** Cleveland dot plot: compare several series per category without a zero-based bar. */
+var DotPlot = class extends BandChart {
+	static meta = {
+		id: "bar-dot-plot",
+		name: "Dot plot",
+		family: ChartFamily.Comparison,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Positions dots along a shared scale so differences between series read without bars or a zero baseline.",
+		tags: [
+			"cleveland",
+			"dot",
+			"strip"
+		],
+		sample: (seed) => SampleData.categories(seed, 8, 3),
+		variants: {
+			orientation: [Orientation.Horizontal, Orientation.Vertical],
+			sort: [BarSort.Data, BarSort.Descending],
+			guide: [
+				"line",
+				"range",
+				"none"
+			],
+			layout: ["overlaid", "dodged"],
+			domain: [
+				"tight",
+				"zero",
+				"log"
+			],
+			symbols: [false, true]
+		},
+		valid: (values) => !(values.guide === "range" && values.layout === "dodged")
+	};
+	defaults() {
+		return {
+			x: "category",
+			y: "value",
+			series: "series",
+			orientation: Orientation.Horizontal,
+			sort: BarSort.Data,
+			guide: "line",
+			layout: "overlaid",
+			domain: "tight",
+			symbols: false
+		};
+	}
+	get logged() {
+		return this.options.domain === "log" && this.dots.some((dot) => dot.value > 0);
+	}
+	get dots() {
+		const { data, x, y, series, sort, domain } = this.options;
+		const pivot = BarRows.pivot(data, x, series, y);
+		return BarRows.order(pivot.bands, sort, pivot.total, (band) => band).flatMap((band) => pivot.series.map((name, slot) => ({
+			band,
+			series: name,
+			slot,
+			value: pivot.cell(band, name),
+			present: pivot.has(band, name)
+		}))).filter((dot) => dot.present && (domain !== "log" || dot.value > 0));
+	}
+	bandNames() {
+		return [...new Set(this.dots.map((dot) => dot.band))];
+	}
+	bandPadding() {
+		return .08;
+	}
+	baseline() {
+		return this.options.domain === "zero" ? 0 : null;
+	}
+	reserve() {
+		return [8, 8];
+	}
+	valueExtent() {
+		const [low = 0, high = 1] = extent(this.dots, (dot) => dot.value);
+		if (this.logged) return [low, high];
+		if (this.options.domain === "zero") return [Math.min(0, low), Math.max(0, high)];
+		return [low, high];
+	}
+	valueScale(domain) {
+		return this.logged ? scaleLog().domain(domain).nice() : super.valueScale(domain);
+	}
+	/** Log ticks carry a label only at 1, 2 and 5 of each decade, so they stay readable. */
+	tickFormat(scale) {
+		const format = super.tickFormat(scale);
+		if (!format || !this.logged || typeof scale.domain()[0] !== "number") return format;
+		return (value) => {
+			const lead = +value / 10 ** Math.floor(Math.log10(+value));
+			return [
+				1,
+				2,
+				5
+			].includes(Math.round(lead * 1e3) / 1e3) ? format(value) : "";
+		};
+	}
+	drawBands(ctx, frame) {
+		const { dots } = this;
+		const { guide, layout, symbols, series } = this.options;
+		const names = [...new Set(dots.map((dot) => dot.series))];
+		const dodged = layout === "dodged";
+		const pitch = dodged ? frame.thick / Math.max(1, names.length) : 0;
+		const at = (d) => frame.center(d.band) + (dodged ? (d.slot - (names.length - 1) / 2) * pitch : 0);
+		this.drawGuides(ctx, frame, dots, at, guide);
+		const marks = ctx.marks("dots", "path", dots, (d) => `${d.band}/${d.series}`).attr("d", (d) => symbol(Scales.symbol(symbols ? SHAPES[d.slot % SHAPES.length] : SymbolKind.Circle), 80)()).attr("fill", (d) => ctx.palette.color(d.series)).attr("stroke", ctx.theme.surface).attr("stroke-width", 2);
+		const low = frame.value.domain()[0];
+		ctx.set(marks, { transform: (d) => `translate(${frame.point(at(d), d.value).join(",")})` }, { transform: (d) => `translate(${frame.point(at(d), low).join(",")})` }, 8);
+		ctx.hover(marks, (d) => ({
+			title: d.band,
+			color: ctx.palette.color(d.series),
+			rows: [[series ? d.series : "Value", d.value]]
+		}));
+	}
+	drawGuides(ctx, frame, dots, at, guide) {
+		const [low, high] = frame.value.domain();
+		const spans = guide === "none" ? [] : guide === "line" ? dots.filter((dot) => this.options.layout === "dodged" || dot.slot === 0).map((dot) => ({
+			key: `${dot.band}/${dot.series}`,
+			at: at(dot),
+			from: low,
+			to: high
+		})) : [...group(dots, (dot) => dot.band)].map(([band, own]) => ({
+			key: band,
+			at: frame.center(band),
+			from: min(own, (dot) => dot.value) ?? low,
+			to: max(own, (dot) => dot.value) ?? low
+		}));
+		const lines = ctx.marks("guides", "line", spans, (d) => d.key).attr("stroke", guide === "range" ? ctx.theme.axis : ctx.theme.grid).attr("stroke-width", guide === "range" ? 2 : 1);
+		ctx.set(lines, {
+			x1: (d) => frame.stem(d.at, d.from, d.to).x1,
+			y1: (d) => frame.stem(d.at, d.from, d.to).y1,
+			x2: (d) => frame.stem(d.at, d.from, d.to).x2,
+			y2: (d) => frame.stem(d.at, d.from, d.to).y2
+		});
+	}
+};
+export { DotPlot, DotPlotDomain, DotPlotGuide, DotPlotLayout };