@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/statistics/ForestPlot.js

@@ -0,0 +1,221 @@
+import { ChartFamily, DataShape, Dimension, ScaleKind } from "../../core/enums.js";
+import { MetaAnalysis, PoolingModel } from "./MetaAnalysis.js";
+import { StatMath } from "./StatMath.js";
+import { StatisticalChart } from "./StatisticalChart.js";
+import { group, scaleBand } from "d3";
+// src/charts/statistics/ForestPlot.ts
+/** Order of studies in a forest plot. */
+var ForestOrder = /* @__PURE__ */ function(ForestOrder) {
+	ForestOrder["Input"] = "input-order";
+	ForestOrder["Effect"] = "by-effect";
+	ForestOrder["Precision"] = "by-precision";
+	return ForestOrder;
+}({});
+/** The standard summary of a meta-analysis: every study's estimate and interval above their pooled result. */
+var ForestPlot = class extends StatisticalChart {
+	static meta = {
+		id: "meta-forest-plot",
+		name: "Forest plot",
+		family: ChartFamily.Statistical,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Lists each study estimate with its confidence interval above the pooled effect in a meta-analysis.",
+		tags: [
+			"meta-analysis",
+			"blobbogram",
+			"odds ratio",
+			"confidence interval"
+		],
+		sample: (seed) => MetaAnalysis.studies(seed, 9),
+		variants: {
+			model: Object.values(PoolingModel),
+			order: Object.values(ForestOrder),
+			weighted: [true, false],
+			prediction: [false, true],
+			scale: [ScaleKind.Linear, ScaleKind.Log],
+			subgroups: [false, true],
+			estimates: [false, true]
+		},
+		valid: ({ model, prediction, subgroups, order }) => !(prediction && model !== PoolingModel.Random) && !(subgroups && order !== "input-order")
+	};
+	defaults() {
+		return {
+			effect: "effect",
+			se: "se",
+			study: "study",
+			subgroup: "subgroup",
+			model: PoolingModel.Fixed,
+			order: "input-order",
+			weighted: true,
+			prediction: false,
+			scale: ScaleKind.Linear,
+			subgroups: false,
+			estimates: false
+		};
+	}
+	axisTitles() {
+		return { x: this.options.scale === ScaleKind.Log ? "Ratio" : "Effect size" };
+	}
+	get logged() {
+		return this.options.scale === ScaleKind.Log;
+	}
+	shown(value) {
+		return this.logged ? Math.exp(value) : value;
+	}
+	rows() {
+		const { data, effect, se, study, subgroup, model, order, subgroups } = this.options;
+		const studies = MetaAnalysis.read(data, {
+			effect,
+			se,
+			study,
+			subgroup
+		});
+		if (order === "by-effect") studies.sort((a, b) => b.effect - a.effect);
+		if (order === "by-precision") studies.sort((a, b) => a.se - b.se);
+		const pooled = MetaAnalysis.pool(studies, model);
+		const weightOf = new Map(studies.map((d, i) => [d, pooled.weights[i]]));
+		const entry = (d, i) => ({
+			key: `${i}|${d.name}`,
+			label: d.name,
+			effect: d.effect,
+			low: d.effect - 1.96 * d.se,
+			high: d.effect + 1.96 * d.se,
+			weight: weightOf.get(d),
+			pooled: false,
+			heading: false
+		});
+		const summary = (key, label, set) => {
+			const { effect: centre, se: error } = MetaAnalysis.pool(set, model);
+			return {
+				key,
+				label,
+				effect: centre,
+				low: centre - 1.96 * error,
+				high: centre + 1.96 * error,
+				weight: 1,
+				pooled: true,
+				heading: false
+			};
+		};
+		const body = subgroups ? [...group(studies, (d) => d.subgroup)].flatMap(([name, set]) => [
+			{
+				key: `head ${name}|${name}`,
+				label: name,
+				effect: 0,
+				low: 0,
+				high: 0,
+				weight: 0,
+				pooled: false,
+				heading: true
+			},
+			...set.map((d) => entry(d, studies.indexOf(d))),
+			summary(`sub ${name}|Subtotal`, "Subtotal", set)
+		]) : studies.map(entry);
+		return studies.length ? [...body, summary("all|Overall", "Overall", studies)] : [];
+	}
+	/** Prediction interval for a new study's true effect. */
+	predictionRange() {
+		const { data, effect, se, study, subgroup, model, prediction } = this.options;
+		const studies = MetaAnalysis.read(data, {
+			effect,
+			se,
+			study,
+			subgroup
+		});
+		if (!prediction || studies.length < 3) return null;
+		const { effect: centre, se: error, tau2 } = MetaAnalysis.pool(studies, model);
+		const reach = StatMath.tQuantile(.975, studies.length - 2) * Math.sqrt(tau2 + error * error);
+		return [centre - reach, centre + reach];
+	}
+	plotMargin() {
+		const base = super.plotMargin();
+		return {
+			...base,
+			right: this.options.estimates ? 116 : base.right,
+			top: base.top + 4
+		};
+	}
+	tickFormat(scale) {
+		if (!("bandwidth" in scale)) return super.tickFormat(scale);
+		const crowded = scale.step() < 11;
+		return (value) => {
+			const label = String(value).split("|").at(-1);
+			if (crowded && String(value).startsWith("sub ")) return "";
+			return label.length > 14 ? `${label.slice(0, 13)}…` : label;
+		};
+	}
+	scales(ctx) {
+		const rows = this.rows(), range = this.predictionRange();
+		const bounds = rows.filter((d) => !d.heading).flatMap((d) => [d.low, d.high]).concat(range ?? [], 0);
+		const [low, high] = this.span(bounds, .05);
+		return {
+			x: this.logged ? this.logarithmic([Math.exp(low), Math.exp(high)], [0, ctx.plot.width]) : this.linear([low, high], [0, ctx.plot.width]),
+			y: scaleBand(rows.map((d) => d.key), [0, ctx.plot.height]).padding(.12)
+		};
+	}
+	plotMarks(ctx, axes) {
+		const { weighted, estimates } = this.options;
+		const rows = this.rows(), range = this.predictionRange();
+		const ink = ctx.palette.color("Studies");
+		const x = (value) => axes.x(this.shown(value));
+		const middle = (d) => axes.y(d.key) + axes.y.bandwidth() / 2;
+		const nullValue = this.logged ? 1 : 0;
+		const rule = ctx.marks("null-line", "line", rows.length ? [nullValue] : []).attr("stroke", ctx.theme.inkSecondary).attr("stroke-width", 1);
+		ctx.set(rule, {
+			x1: (d) => axes.x(d),
+			x2: (d) => axes.x(d),
+			y1: 0,
+			y2: ctx.plot.height
+		});
+		const studies = rows.filter((d) => !d.pooled && !d.heading);
+		const whiskers = ctx.marks("intervals", "line", studies, (d) => d.key).attr("stroke", ink).attr("stroke-width", 2).attr("stroke-linecap", "round");
+		ctx.set(whiskers, {
+			x1: (d) => x(d.low),
+			x2: (d) => x(d.high),
+			y1: middle,
+			y2: middle
+		}, {
+			x1: (d) => x(d.effect),
+			x2: (d) => x(d.effect),
+			y1: middle,
+			y2: middle
+		}, 20);
+		const largest = Math.max(1e-9, ...studies.map((d) => d.weight)), cap = Math.min(14, axes.y.bandwidth());
+		const side = (d) => weighted ? Math.max(6, cap * Math.sqrt(d.weight / largest)) : 8;
+		const squares = ctx.marks("squares", "rect", studies, (d) => d.key).attr("fill", ink).attr("rx", 1);
+		ctx.set(squares, {
+			x: (d) => x(d.effect) - side(d) / 2,
+			y: (d) => middle(d) - side(d) / 2,
+			width: side,
+			height: side
+		}, {
+			x: (d) => x(d.effect),
+			y: middle,
+			width: 0,
+			height: 0
+		}, 20);
+		const interval = (d) => `${this.shown(d.effect).toFixed(2)} [${this.shown(d.low).toFixed(2)}, ${this.shown(d.high).toFixed(2)}]`;
+		const tip = (d) => ({
+			title: d.label,
+			color: ink,
+			rows: [["Estimate", interval(d)], ...d.pooled ? [] : [["Weight", `${(d.weight * 100).toFixed(1)}%`]]]
+		});
+		ctx.hover(squares, tip);
+		const diamonds = ctx.marks("diamonds", "path", rows.filter((d) => d.pooled), (d) => d.key).attr("fill", ctx.theme.ink);
+		const half = Math.min(7, axes.y.bandwidth() / 2);
+		const shape = (d) => `M${x(d.low)},${middle(d)}L${x(d.effect)},${middle(d) - half}L${x(d.high)},${middle(d)}L${x(d.effect)},${middle(d) + half}Z`;
+		ctx.set(diamonds, { d: shape }, { d: shape });
+		ctx.hover(diamonds, tip);
+		const overall = rows.at(-1);
+		const predict = ctx.marks("prediction", "line", range && overall ? [range] : []).attr("stroke", ctx.theme.ink).attr("stroke-width", 2);
+		ctx.set(predict, {
+			x1: (d) => x(d[0]),
+			x2: (d) => x(d[1]),
+			y1: overall ? middle(overall) : 0,
+			y2: overall ? middle(overall) : 0
+		});
+		const column = ctx.marks("estimates", "text", estimates && axes.y.bandwidth() >= 9 ? rows.filter((d) => !d.heading) : [], (d) => d.key).attr("x", ctx.plot.width + 8).attr("y", (d) => middle(d) + 4).text(interval);
+		ctx.text(column, 10.5);
+	}
+};
+export { ForestOrder, ForestPlot };

package/dist/charts/statistics/FunnelPlot.js

@@ -0,0 +1,196 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { MetaAnalysis, PoolingModel } from "./MetaAnalysis.js";
+import { RegressionFit } from "./RegressionFit.js";
+import { StatMath } from "./StatMath.js";
+import { StatisticalChart } from "./StatisticalChart.js";
+// src/charts/statistics/FunnelPlot.ts
+/** Precision measure on the vertical axis of a funnel plot. */
+var FunnelPrecision = /* @__PURE__ */ function(FunnelPrecision) {
+	FunnelPrecision["StandardError"] = "standard-error";
+	FunnelPrecision["InverseError"] = "inverse-error";
+	FunnelPrecision["Variance"] = "variance";
+	return FunnelPrecision;
+}({});
+/** Reference regions drawn behind the studies. */
+var FunnelContours = /* @__PURE__ */ function(FunnelContours) {
+	FunnelContours["Confidence"] = "confidence-funnel";
+	FunnelContours["Significance"] = "contour-enhanced";
+	FunnelContours["None"] = "no-funnel";
+	return FunnelContours;
+}({});
+/** Screens a meta-analysis for publication bias: unbiased studies form a symmetric funnel around the pooled effect. */
+var FunnelPlot = class extends StatisticalChart {
+	static meta = {
+		id: "meta-funnel-plot",
+		name: "Funnel plot",
+		family: ChartFamily.Statistical,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots each study effect against its precision to reveal publication bias in a meta-analysis.",
+		tags: [
+			"meta-analysis",
+			"publication bias",
+			"egger",
+			"trim and fill"
+		],
+		sample: (seed) => MetaAnalysis.studies(seed, 24),
+		variants: {
+			precision: Object.values(FunnelPrecision),
+			model: Object.values(PoolingModel),
+			contours: Object.values(FunnelContours),
+			egger: [false, true],
+			trimFill: [false, true]
+		}
+	};
+	defaults() {
+		return {
+			effect: "effect",
+			se: "se",
+			study: "study",
+			precision: "standard-error",
+			model: PoolingModel.Fixed,
+			contours: "confidence-funnel",
+			egger: false,
+			trimFill: false
+		};
+	}
+	axisTitles() {
+		return {
+			x: "Effect size",
+			y: {
+				["standard-error"]: "Standard error",
+				["inverse-error"]: "Precision (1/SE)",
+				["variance"]: "Variance"
+			}[this.options.precision]
+		};
+	}
+	height(se) {
+		const { precision } = this.options;
+		return precision === "standard-error" ? se : precision === "inverse-error" ? 1 / se : se * se;
+	}
+	studies() {
+		const { data, effect, se, study } = this.options;
+		return MetaAnalysis.read(data, {
+			effect,
+			se,
+			study,
+			subgroup: study
+		});
+	}
+	seMax(studies) {
+		return Math.max(.001, ...studies.map((d) => d.se)) * 1.1;
+	}
+	/** Standard errors from the top of the visible axis to the bottom of the funnel. */
+	grid(seMax, axes) {
+		const top = Math.max(...axes.y.domain());
+		const start = this.options.precision === "inverse-error" ? 1 / top : seMax * .002;
+		return Array.from({ length: 40 }, (_, i) => start + (seMax - start) * i / 39);
+	}
+	scales(ctx) {
+		const { contours, precision, trimFill, model } = this.options;
+		const studies = this.studies(), seMax = this.seMax(studies);
+		const imputed = trimFill ? MetaAnalysis.trimAndFill(studies, model) : [];
+		const pooled = MetaAnalysis.pool(studies, model).effect;
+		const reach = contours === "no-funnel" ? 0 : 2.6 * seMax;
+		const centre = contours === "contour-enhanced" ? 0 : pooled;
+		const x = this.span([...studies, ...imputed].map((d) => d.effect).concat(centre - reach, centre + reach, 0), .04);
+		const spot = studies.length ? studies.map((d) => this.height(d.se)) : [1];
+		const y = precision === "inverse-error" ? [0, Math.max(...spot) * 1.1] : [this.height(seMax), 0];
+		return {
+			x: this.linear(x, [0, ctx.plot.width]),
+			y: this.linear(y, [ctx.plot.height, 0])
+		};
+	}
+	/** The funnel runs along y, so it is a closed polygon rather than a ribbon. */
+	polygon(centre, z, grid) {
+		return [...grid.map((se) => [centre - z * se, this.height(se)]), ...[...grid].reverse().map((se) => [centre + z * se, this.height(se)])];
+	}
+	plotMarks(ctx, axes) {
+		const { contours, model, egger, trimFill } = this.options;
+		const studies = this.studies(), seMax = this.seMax(studies);
+		const pooled = MetaAnalysis.pool(studies, model);
+		const significance = contours === "contour-enhanced";
+		const zones = contours === "no-funnel" ? [] : significance ? [
+			{
+				z: 2.576,
+				t: .16
+			},
+			{
+				z: 1.96,
+				t: .2
+			},
+			{
+				z: 1.645,
+				t: .26
+			}
+		] : [{
+			z: 1.96,
+			t: .28
+		}];
+		const [left, right] = axes.x.domain();
+		const clamp = ([x, y]) => [Math.max(left, Math.min(right, x)), y];
+		const zone = ctx.marks("funnel", "path", zones, (d) => d.z).attr("fill", ctx.theme.inkMuted).attr("fill-opacity", (d) => d.t).attr("stroke", "none");
+		const grid = this.grid(seMax, axes);
+		const shape = (d) => `M${this.polygon(significance ? 0 : pooled.effect, d.z, grid).map(clamp).map(([x, y]) => `${axes.x(x)},${axes.y(y)}`).join("L")}Z`;
+		ctx.set(zone, { d: shape }, { d: shape });
+		const [bottom, top] = axes.y.domain();
+		this.rules(ctx, "pooled", [{
+			key: "pooled",
+			from: [pooled.effect, bottom],
+			to: [pooled.effect, top],
+			strong: true
+		}], axes);
+		this.rules(ctx, "null", [{
+			key: "null",
+			from: [0, bottom],
+			to: [0, top],
+			dash: "2 3"
+		}], axes);
+		const ink = ctx.palette.color("Studies");
+		if (egger && studies.length > 2) {
+			const fit = new RegressionFit(studies.map((d) => 1 / d.se), studies.map((d) => d.effect / d.se));
+			const slope = fit.predict(1) - fit.predict(0), intercept = fit.predict(0);
+			this.traces(ctx, "egger", [{
+				key: "Egger regression",
+				color: ctx.theme.ink,
+				dash: "6 3",
+				tip: {
+					title: "Egger's test",
+					rows: [["Intercept", +intercept.toFixed(3)]]
+				},
+				points: grid.map((se) => clamp([slope + intercept * se, this.height(se)]))
+			}], axes);
+		} else this.traces(ctx, "egger", [], axes);
+		const imputed = trimFill ? MetaAnalysis.trimAndFill(studies, model) : [];
+		const hollow = ctx.marks("imputed", "circle", imputed, (d) => d.name).attr("fill", ctx.theme.surface).attr("stroke", ink).attr("stroke-width", 2);
+		const cx = (d) => axes.x(d.effect), cy = (d) => axes.y(this.height(d.se));
+		ctx.set(hollow, {
+			cx,
+			cy,
+			r: 4
+		}, {
+			cx,
+			cy,
+			r: 0
+		});
+		const tip = (d) => ({
+			title: d.name,
+			color: ink,
+			rows: [
+				["Effect", d.effect],
+				["Standard error", d.se],
+				["p", +StatMath.twoSided(d.effect / d.se).toPrecision(2)]
+			]
+		});
+		ctx.hover(hollow, tip);
+		this.dots(ctx, "studies", studies, (d) => [cx(d), cy(d)], () => ink, tip, { key: (d, i) => `${d.name}/${i}` });
+		this.notes(ctx, "pooled-label", studies.length ? [{
+			key: "pooled",
+			text: `Pooled ${pooled.effect.toFixed(2)}`,
+			x: axes.x(pooled.effect) + 5,
+			y: 12,
+			tone: "secondary"
+		}] : []);
+	}
+};
+export { FunnelContours, FunnelPlot, FunnelPrecision };

package/dist/charts/statistics/InteractionPlot.js

@@ -0,0 +1,207 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { StatMath } from "./StatMath.js";
+import { StatisticalChart } from "./StatisticalChart.js";
+import { deviation, group, mean } from "d3";
+// src/charts/statistics/InteractionPlot.ts
+/** Error bar on each cell mean. */
+var InteractionError = /* @__PURE__ */ function(InteractionError) {
+	InteractionError["None"] = "no-error";
+	InteractionError["StandardError"] = "standard-error";
+	InteractionError["Confidence"] = "ci-95";
+	InteractionError["Deviation"] = "std-deviation";
+	return InteractionError;
+}({});
+/** What the vertical axis keeps of each cell mean. */
+var InteractionEffect = /* @__PURE__ */ function(InteractionEffect) {
+	InteractionEffect["Means"] = "cell-means";
+	InteractionEffect["Residual"] = "interaction-only";
+	return InteractionEffect;
+}({});
+/** Two-factor designs: parallel lines mean the factors act independently, crossing or diverging lines mean they interact. */
+var InteractionPlot = class extends StatisticalChart {
+	static meta = {
+		id: "interaction-plot",
+		name: "Interaction plot",
+		family: ChartFamily.Statistical,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Traces cell means of one factor across another, where non-parallel lines reveal an interaction effect.",
+		tags: [
+			"anova",
+			"factorial",
+			"doe",
+			"experiment",
+			"means"
+		],
+		sample: (seed) => Array.from({ length: 6 }, (_, i) => SampleData.categories(seed + i, 4, 3)).flat().map((row, i) => ({
+			...row,
+			value: +row.value / 4 + (row.series === "Alpha" ? [
+				"North",
+				"South",
+				"East",
+				"West"
+			].indexOf(String(row.category)) * 9 : row.series === "Bravo" ? i % 4 + 12 : 26 - [
+				"North",
+				"South",
+				"East",
+				"West"
+			].indexOf(String(row.category)) * 5)
+		})),
+		variants: {
+			swapped: [false, true],
+			error: Object.values(InteractionError),
+			dodged: [false, true],
+			effect: Object.values(InteractionEffect),
+			raw: [false, true],
+			additive: [false, true]
+		},
+		valid: ({ error, dodged, effect, additive, raw }) => !(dodged && error === "no-error" && !raw) && !(effect === "interaction-only" && (additive || raw))
+	};
+	defaults() {
+		return {
+			x: "category",
+			series: "series",
+			y: "value",
+			swapped: false,
+			error: "standard-error",
+			dodged: false,
+			effect: "cell-means",
+			raw: false,
+			additive: false
+		};
+	}
+	get fields() {
+		const { x, series, swapped } = this.options;
+		return swapped ? {
+			axis: series,
+			trace: x
+		} : {
+			axis: x,
+			trace: series
+		};
+	}
+	axisTitles() {
+		const title = (name) => name.charAt(0).toUpperCase() + name.slice(1);
+		return {
+			x: title(this.fields.axis),
+			y: this.options.effect === "interaction-only" ? "Interaction effect" : `Mean ${this.options.y}`
+		};
+	}
+	cells() {
+		const { data, y, error, effect } = this.options;
+		const { axis, trace } = this.fields;
+		const rows = this.complete(data, y);
+		const levels = [...new Set(rows.map((row) => String(row[axis])))], traces = [...new Set(rows.map((row) => String(row[trace])))];
+		const byCell = group(rows, (row) => String(row[axis]), (row) => String(row[trace]));
+		const grand = mean(rows, (row) => +row[y]) ?? 0;
+		const marginal = (field, name) => (mean(rows.filter((row) => String(row[field]) === name), (row) => +row[y]) ?? grand) - grand;
+		return {
+			cells: levels.flatMap((level) => traces.flatMap((name) => {
+				const values = byCell.get(level)?.get(name)?.map((row) => +row[y]) ?? [];
+				if (!values.length) return [];
+				const n = values.length, sd = deviation(values) ?? 0, se = sd / Math.sqrt(n);
+				const half = {
+					["no-error"]: 0,
+					["standard-error"]: se,
+					["ci-95"]: (n > 1 ? StatMath.tQuantile(.975, n - 1) : 0) * se,
+					["std-deviation"]: sd
+				}[error];
+				const additive = grand + marginal(axis, level) + marginal(trace, name);
+				return [{
+					axis: level,
+					trace: name,
+					mean: effect === "interaction-only" ? mean(values) - additive : mean(values),
+					half,
+					n,
+					rawValues: values,
+					additive
+				}];
+			})),
+			levels,
+			traces
+		};
+	}
+	scales(ctx) {
+		const { cells, levels } = this.cells(), { raw, additive } = this.options;
+		const stops = levels.map((name, i) => [i, name.length > 12 ? `${name.slice(0, 11)}…` : name]);
+		const x = this.labelled(this.linear([-.35, Math.max(1, levels.length - 1) + .35], [0, ctx.plot.width]), stops);
+		const values = cells.flatMap((d) => [
+			d.mean - d.half,
+			d.mean + d.half,
+			...raw ? d.rawValues : [],
+			...additive ? [d.additive] : []
+		]);
+		return {
+			x,
+			y: this.linear(this.span(values), [ctx.plot.height, 0])
+		};
+	}
+	plotMarks(ctx, axes) {
+		const { dodged, raw, additive, error, effect } = this.options;
+		const { cells, levels, traces } = this.cells();
+		const color = (name) => ctx.palette.color(name);
+		const shift = (name) => dodged ? ((traces.indexOf(name) + .5) / traces.length - .5) * .24 : 0;
+		const place = (d) => levels.indexOf(d.axis) + shift(d.trace);
+		if (effect === "interaction-only") this.rules(ctx, "zero", [{
+			key: "zero",
+			from: [-.35, 0],
+			to: [levels.length - 1 + .35, 0],
+			strong: true
+		}], axes);
+		else this.rules(ctx, "zero", [], axes);
+		const points = raw ? cells.flatMap((d) => d.rawValues.map((value, i) => ({
+			d,
+			value,
+			i
+		}))) : [];
+		const jitter = (i) => (i * 37 % 11 / 10 - .5) * .07;
+		const scatter = ctx.marks("raw", "circle", points, ({ d, i }) => `${d.axis}/${d.trace}/${i}`).attr("fill", ({ d }) => color(d.trace)).attr("fill-opacity", .3);
+		ctx.set(scatter, {
+			cx: ({ d, i }) => axes.x(place(d) + jitter(i)),
+			cy: ({ value }) => axes.y(value),
+			r: 2.5
+		});
+		ctx.hover(scatter, ({ d, value }) => ({
+			title: `${d.axis} × ${d.trace}`,
+			color: color(d.trace),
+			rows: [["Observation", value]]
+		}));
+		this.traces(ctx, "additive", additive ? traces.map((name) => ({
+			key: `${name} additive`,
+			color: color(name),
+			dash: "5 4",
+			width: 1.5,
+			tip: {
+				title: `${name}, no interaction`,
+				color: color(name)
+			},
+			points: cells.filter((d) => d.trace === name).map((d) => [place(d), d.additive])
+		})) : [], axes);
+		const bars = ctx.marks("errors", "line", error === "no-error" ? [] : cells, (d) => `${d.axis}/${d.trace}`).attr("stroke", (d) => color(d.trace)).attr("stroke-width", 2).attr("stroke-linecap", "round");
+		ctx.set(bars, {
+			x1: (d) => axes.x(place(d)),
+			x2: (d) => axes.x(place(d)),
+			y1: (d) => axes.y(d.mean - d.half),
+			y2: (d) => axes.y(d.mean + d.half)
+		});
+		this.traces(ctx, "means", traces.map((name) => ({
+			key: name,
+			color: color(name),
+			points: cells.filter((d) => d.trace === name).map((d) => [place(d), d.mean])
+		})), axes);
+		this.dots(ctx, "cells", cells, (d) => [axes.x(place(d)), axes.y(d.mean)], (d) => color(d.trace), (d) => ({
+			title: `${d.axis} × ${d.trace}`,
+			color: color(d.trace),
+			rows: [
+				["Mean", +d.mean.toFixed(2)],
+				["Observations", d.n],
+				...d.half ? [["Error", `±${d.half.toFixed(2)}`]] : []
+			]
+		}), {
+			key: (d) => `${d.axis}/${d.trace}`,
+			r: 5
+		});
+	}
+};
+export { InteractionEffect, InteractionError, InteractionPlot };