@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/signals/FilterResponseChart.js

@@ -0,0 +1,264 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { ZoomAxis } from "../../core/ChartViewport.js";
+import { SampleData } from "../../data/SampleData.js";
+import { SignalChart } from "./SignalChart.js";
+import { SignalAmplitude, SignalFrequencyScale } from "./SignalEnums.js";
+import { SignalScales } from "./SignalScales.js";
+import { group, max, min, scaleLinear } from "d3";
+// src/charts/signals/FilterResponseChart.ts
+var FilterView = /* @__PURE__ */ function(FilterView) {
+	FilterView["Bode"] = "bode";
+	FilterView["Magnitude"] = "magnitude";
+	FilterView["Phase"] = "phase";
+	FilterView["GroupDelay"] = "group-delay";
+	FilterView["Nyquist"] = "nyquist";
+	return FilterView;
+}({});
+var unwrapped = (phase) => {
+	const out = [...phase];
+	for (let i = 1; i < out.length; i++) out[i] -= 360 * Math.round((out[i] - out[i - 1]) / 360);
+	return out;
+};
+var SAMPLE_POINTS = 140;
+/** Evaluates a low-pass prototype at `w` (rad/s normalised to cutoff) from its poles. */
+var response = (poles, w) => {
+	let gain = 1, phase = 0;
+	for (const [re, im] of poles) {
+		gain *= Math.hypot(re, im) / Math.hypot(re, w - im);
+		phase -= Math.atan2(w - im, -re);
+	}
+	return [20 * Math.log10(gain), phase * 180 / Math.PI];
+};
+var butterworth = (order) => Array.from({ length: order }, (_, k) => {
+	const angle = Math.PI * (2 * k + 1 + order) / (2 * order);
+	return [Math.cos(angle), Math.sin(angle)];
+});
+var chebyshev = (order, ripple) => {
+	const epsilon = Math.sqrt(10 ** (ripple / 10) - 1), mu = Math.asinh(1 / epsilon) / order;
+	return butterworth(order).map(([re, im]) => [re * Math.sinh(mu), im * Math.cosh(mu)]);
+};
+var BESSEL = [
+	[-.6573, .8302],
+	[-.6573, -.8302],
+	[-.9047, .2711],
+	[-.9047, -.2711]
+].map(([re, im]) => [re * 1.2, im * 1.2]);
+/** Frequency response of a filter or system: Bode plot, group delay or Nyquist diagram. */
+var FilterResponseChart = class extends SignalChart {
+	static meta = {
+		id: "signal-filter-response",
+		name: "Filter response",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Shows the gain, phase and delay of a filter across frequency as a Bode plot, group delay or Nyquist diagram.",
+		tags: [
+			"bode",
+			"nyquist",
+			"group delay",
+			"butterworth",
+			"chebyshev"
+		],
+		sample: (seed) => {
+			const cutoff = 400 + +SampleData.categories(seed, 1, 1)[0].value * 6;
+			return [
+				["Butterworth", butterworth(4)],
+				["Chebyshev", chebyshev(4, 1)],
+				["Bessel", BESSEL]
+			].flatMap(([series, poles]) => {
+				return unwrapped(Array.from({ length: SAMPLE_POINTS }, (_, i) => response(poles, .02 * 500 ** (i / 139))[1])).map((value, i) => {
+					const w = .02 * 500 ** (i / 139), [gain] = response(poles, w);
+					return {
+						frequency: +(w * cutoff).toFixed(2),
+						gain: +gain.toFixed(3),
+						phase: +value.toFixed(2),
+						series
+					};
+				});
+			});
+		},
+		variants: {
+			view: Object.values(FilterView),
+			frequency: [SignalFrequencyScale.Log, SignalFrequencyScale.Linear],
+			amplitude: Object.values(SignalAmplitude),
+			cutoff: [true, false],
+			unwrap: [true, false]
+		},
+		valid: (values) => {
+			const { view, frequency, amplitude, cutoff, unwrap } = values;
+			if (view === "nyquist") return frequency === SignalFrequencyScale.Log && amplitude === SignalAmplitude.Decibel && cutoff === true && unwrap === true;
+			if (view !== "bode" && view !== "magnitude" && amplitude !== SignalAmplitude.Decibel) return false;
+			if (view !== "bode" && view !== "phase" && unwrap !== true) return false;
+			if (view !== "bode" && view !== "magnitude" && cutoff !== true) return false;
+			return true;
+		}
+	};
+	get legended() {
+		return this.sweeps.length > 1;
+	}
+	zoomAxes() {
+		return ZoomAxis.X;
+	}
+	defaults() {
+		return {
+			...super.defaults(),
+			x: "frequency",
+			gain: "gain",
+			phase: "phase",
+			xLabel: "Frequency (Hz)",
+			yLabel: void 0,
+			view: "bode",
+			frequency: SignalFrequencyScale.Log,
+			amplitude: SignalAmplitude.Decibel,
+			cutoff: true,
+			unwrap: true
+		};
+	}
+	constructor(options) {
+		const view = options.view ?? "bode", nyquist = view === "nyquist";
+		const label = {
+			["bode"]: void 0,
+			["magnitude"]: options.amplitude === SignalAmplitude.Linear ? "Gain" : "Gain (dB)",
+			["phase"]: "Phase (°)",
+			["group-delay"]: "Group delay (ms)",
+			["nyquist"]: "Imaginary"
+		}[view];
+		super({
+			yLabel: label,
+			...nyquist ? { xLabel: "Real" } : {},
+			...options
+		});
+	}
+	get sweeps() {
+		const { data, x, gain, phase, series } = this.options;
+		return [...group(data ?? [], (row) => String(row[series] ?? "Filter"))].map(([name, rows]) => {
+			const clean = rows.filter((row) => +row[x] > 0 && Number.isFinite(+row[gain]) && row[gain] !== null).sort((a, b) => +a[x] - +b[x]);
+			const freq = clean.map((row) => +row[x]), rise = unwrapped(clean.map((row) => +row[phase] || 0));
+			const delay = rise.map((_, i) => {
+				const a = Math.max(0, i - 1), b = Math.min(rise.length - 1, i + 1);
+				return freq[b] > freq[a] ? -((rise[b] - rise[a]) / 360 / (freq[b] - freq[a])) * 1e3 : 0;
+			});
+			return {
+				name,
+				freq,
+				gain: clean.map((row) => +row[gain]),
+				phase: rise,
+				delay
+			};
+		});
+	}
+	get bode() {
+		return this.options.view === "bode";
+	}
+	get linearGain() {
+		return this.options.amplitude === SignalAmplitude.Linear;
+	}
+	gain(value) {
+		return this.linearGain ? 10 ** (value / 20) : value;
+	}
+	phase(value) {
+		return this.options.unwrap ? value : ((value + 180) % 360 + 360) % 360 - 180;
+	}
+	split(height) {
+		return Math.round(height * .56);
+	}
+	gainScale(top, bottom) {
+		return this.linearGain ? scaleLinear([0, Math.max(1.2, ...this.sweeps.flatMap((sweep) => sweep.gain.map((value) => this.gain(value))))], [bottom, top]).nice(4) : scaleLinear([Math.max(-140, Math.min(-40, ...this.sweeps.flatMap((sweep) => sweep.gain))), Math.max(6, ...this.sweeps.flatMap((sweep) => sweep.gain))], [bottom, top]).nice(4);
+	}
+	phaseScale(top, bottom) {
+		const all = this.sweeps.flatMap((sweep) => sweep.phase.map((value) => this.phase(value)));
+		const low = Math.floor((min(all) ?? -180) / 90) * 90, high = Math.ceil((max(all) ?? 0) / 90) * 90;
+		const scale = scaleLinear([low, high === low ? low + 90 : high], [bottom, top]);
+		const step = high - low > 360 ? 180 : 90;
+		return SignalScales.labelled(scale, scale.ticks(12).filter((tick) => tick % step === 0), (value) => `${value}`);
+	}
+	scales(ctx) {
+		const { width, height } = ctx.plot, { view, frequency } = this.options, sweeps = this.sweeps;
+		if (view === "nyquist") {
+			const extent = Math.max(1.1, ...sweeps.flatMap((sweep) => sweep.gain.map((value) => 10 ** (value / 20)))) * 1.1;
+			const ratio = width / height;
+			return {
+				x: scaleLinear([-extent * ratio, extent * ratio], [0, width]),
+				y: scaleLinear([-extent, extent], [height, 0])
+			};
+		}
+		const freqs = sweeps.flatMap((sweep) => sweep.freq), lo = min(freqs) ?? 1, hi = max(freqs) ?? 10;
+		const x = SignalScales.frequency(frequency, [frequency === SignalFrequencyScale.Linear ? 0 : lo, hi], [0, width]);
+		if (this.bode) return {
+			x,
+			y: this.gainScale(0, this.split(height) - 12)
+		};
+		if (view === "magnitude") return {
+			x,
+			y: this.gainScale(0, height)
+		};
+		if (view === "phase") return {
+			x,
+			y: this.phaseScale(0, height)
+		};
+		const delays = sweeps.flatMap((sweep) => sweep.delay);
+		return {
+			x,
+			y: scaleLinear([0, max(delays) || 1], [height, 0]).nice(4)
+		};
+	}
+	plotMarks(ctx, { x, y }) {
+		const { view, cutoff } = this.options, { width, height } = ctx.plot, sweeps = this.sweeps;
+		const color = (sweep) => ctx.palette.color(sweep.name);
+		if (view === "nyquist") return this.nyquist(ctx, sweeps, x, y);
+		const reading = (sweep) => view === "phase" ? sweep.phase.map((value) => this.phase(value)) : view === "group-delay" ? sweep.delay : sweep.gain.map((value) => this.gain(value));
+		const inRange = (sweep, values) => sweep.freq.map((freq, i) => [freq, values[i]]).filter(([freq]) => x(freq) <= width + .5);
+		if (cutoff && (this.bode || view === "magnitude")) this.cutoff(ctx, sweeps, x, y);
+		this.stroke(ctx, "curve", sweeps, (sweep) => sweep.name, (sweep) => {
+			const [floor, top] = y.domain();
+			return this.path(inRange(sweep, reading(sweep)).map(([freq, value]) => [freq, Math.max(floor, Math.min(top, value))]), x, y);
+		}, color);
+		if (this.bode) {
+			const start = this.split(height) + 12, phase = this.phaseScale(start, height);
+			this.panelAxis(ctx, "phase-axis", phase);
+			ctx.marks("phase-grid", "line", phase.ticks(), (tick) => tick).attr("x1", 0).attr("x2", width).attr("y1", (tick) => phase(tick)).attr("y2", (tick) => phase(tick)).attr("stroke", ctx.theme.grid);
+			this.stroke(ctx, "phase", sweeps, (sweep) => sweep.name, (sweep) => this.path(inRange(sweep, sweep.phase.map((value) => this.phase(value))), x, phase), color);
+		}
+		this.probe(ctx, (px) => {
+			const freq = x.invert(px);
+			return sweeps.length ? {
+				x: px,
+				tip: {
+					title: `${SignalScales.hertz(freq)} Hz`,
+					rows: sweeps.map((sweep) => {
+						const nearest = sweep.freq.reduce((best, value, i) => Math.abs(value - freq) < Math.abs(sweep.freq[best] - freq) ? i : best, 0);
+						return [sweep.name, `${SignalScales.number(sweep.gain[nearest] ?? 0)} dB, ${SignalScales.number(sweep.phase[nearest] ?? 0)}°`];
+					})
+				},
+				datum: { frequency: freq }
+			} : null;
+		});
+	}
+	cutoff(ctx, sweeps, x, y) {
+		const first = sweeps[0];
+		if (!first?.freq.length) return;
+		const reference = first.gain[0], hit = first.gain.findIndex((value) => value <= reference - 3);
+		if (hit <= 0) return;
+		const at = x(first.freq[hit]), bottom = y.range()[0];
+		ctx.marks("passband", "rect", [0]).attr("x", 0).attr("y", 0).attr("width", Math.max(0, at)).attr("height", bottom).attr("fill", ctx.theme.grid).attr("opacity", .4);
+		const dot = ctx.marks("cutoff", "circle", [0]).attr("fill", ctx.palette.color(first.name)).attr("stroke", ctx.theme.surface).attr("stroke-width", 2);
+		ctx.set(dot, {
+			cx: at,
+			cy: y(this.gain(first.gain[hit])),
+			r: 4
+		}, { r: 0 });
+		ctx.text(ctx.marks("cutoff-text", "text", [0]).attr("x", at + (at > ctx.plot.width - 90 ? -8 : 8)).attr("y", 13).attr("text-anchor", at > ctx.plot.width - 90 ? "end" : "start").text(`−3 dB ${SignalScales.hertz(first.freq[hit])} Hz`), 11, "ink");
+	}
+	nyquist(ctx, sweeps, x, y) {
+		const unit = Array.from({ length: 73 }, (_, i) => [Math.cos(i * Math.PI / 36), Math.sin(i * Math.PI / 36)]);
+		ctx.marks("unit", "path", [0]).attr("fill", "none").attr("stroke", ctx.theme.axis).attr("stroke-dasharray", "4 3").attr("d", this.path(unit, x, y));
+		ctx.marks("axes", "path", [0]).attr("fill", "none").attr("stroke", ctx.theme.axis).attr("d", `M${x(0)} 0V${ctx.plot.height}M0 ${y(0)}H${ctx.plot.width}`);
+		const points = (sweep) => sweep.gain.map((gain, i) => {
+			const magnitude = 10 ** (gain / 20), angle = sweep.phase[i] * Math.PI / 180;
+			return [magnitude * Math.cos(angle), magnitude * Math.sin(angle)];
+		});
+		this.stroke(ctx, "curve", sweeps, (sweep) => sweep.name, (sweep) => this.path(points(sweep), x, y), (sweep) => ctx.palette.color(sweep.name));
+		this.stroke(ctx, "mirror", sweeps, (sweep) => sweep.name, (sweep) => this.path(points(sweep).map(([re, im]) => [re, -im]), x, y), (sweep) => ctx.palette.color(sweep.name), 1).attr("stroke-dasharray", "3 3");
+	}
+};
+export { FilterResponseChart, FilterView };

package/dist/charts/signals/ImpulseResponseChart.js

@@ -0,0 +1,199 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SignalChart } from "./SignalChart.js";
+import { SignalSamples } from "./SignalSamples.js";
+import { SignalScales } from "./SignalScales.js";
+import { area, scaleLinear, scaleLog } from "d3";
+// src/charts/signals/ImpulseResponseChart.ts
+var ImpulseView = /* @__PURE__ */ function(ImpulseView) {
+	ImpulseView["Impulse"] = "impulse";
+	ImpulseView["Step"] = "step";
+	ImpulseView["EnergyDecay"] = "energy-decay";
+	return ImpulseView;
+}({});
+var ImpulseMark = /* @__PURE__ */ function(ImpulseMark) {
+	ImpulseMark["Line"] = "line";
+	ImpulseMark["Area"] = "area";
+	ImpulseMark["Stem"] = "stem";
+	return ImpulseMark;
+}({});
+var ImpulseTime = /* @__PURE__ */ function(ImpulseTime) {
+	ImpulseTime["Linear"] = "linear";
+	ImpulseTime["Log"] = "log";
+	return ImpulseTime;
+}({});
+var FLOOR = -70;
+var STEMS = 48;
+/** Characterises a system from its response to a click: ringing, settling, or room reverberation. */
+var ImpulseResponseChart = class extends SignalChart {
+	static meta = {
+		id: "signal-impulse-response",
+		name: "Impulse response",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Shows a system response to an impulse, its integrated step response or Schroeder energy decay.",
+		tags: [
+			"step response",
+			"schroeder",
+			"rt60",
+			"settling",
+			"reverberation"
+		],
+		sample: (seed) => SignalSamples.noise(seed, 1200, 2).flatMap(({ name, noise }, channel) => noise.map((step, i) => {
+			const t = (i + 1) / 2400, ring = 1 + channel * .8;
+			return {
+				t: +t.toFixed(5),
+				series: name,
+				value: +(Math.exp(-t * 9 * ring) * Math.sin(2 * Math.PI * 21 * ring * t) + .4 * Math.exp(-t * 26) * Math.sin(2 * Math.PI * 64 * t) + Math.exp(-t * 7) * step * .012).toFixed(5)
+			};
+		})),
+		variants: {
+			view: Object.values(ImpulseView),
+			mark: Object.values(ImpulseMark),
+			time: Object.values(ImpulseTime),
+			annotate: [true, false]
+		},
+		valid: (values) => values.view !== "energy-decay" || values.mark !== "stem"
+	};
+	constructor(options) {
+		super({
+			yLabel: options.view === "energy-decay" ? "Energy (dB)" : options.view === "step" ? "Step response" : "Amplitude",
+			...options
+		});
+	}
+	defaults() {
+		return {
+			...super.defaults(),
+			view: "impulse",
+			mark: "line",
+			time: "linear",
+			annotate: true
+		};
+	}
+	transform(channel) {
+		const { view } = this.options;
+		if (view === "impulse") return channel.v;
+		if (view === "step") {
+			let sum = 0;
+			return channel.v.map((value) => sum += value / channel.rate);
+		}
+		const decay = new Array(channel.v.length);
+		let sum = 0;
+		for (let i = channel.v.length - 1; i >= 0; i--) decay[i] = sum += channel.v[i] ** 2;
+		return decay.map((value) => Math.max(FLOOR, 10 * Math.log10(value / (decay[0] || 1) || 1e-12)));
+	}
+	curves(ctx, width) {
+		const log = this.options.time === "log";
+		return this.channels.map((channel) => {
+			const keep = this.transform(channel).map((value, i) => [channel.t[i], value]).filter(([t]) => !log || t > 0);
+			const thin = this.thin({
+				...channel,
+				t: keep.map((p) => p[0])
+			}, keep.map((p) => p[1]), width);
+			return {
+				name: channel.name,
+				color: ctx.palette.color(channel.name),
+				points: thin
+			};
+		});
+	}
+	scales(ctx) {
+		const { width, height } = ctx.plot, [lo, hi] = this.span;
+		const positive = this.channels.flatMap((channel) => channel.t.filter((t) => t > 0)[0] ?? []), least = positive.length ? Math.min(...positive) : hi / 1e3 || .001;
+		const x = this.options.time === "log" ? scaleLog([least, Math.max(hi, least * 10)], [0, width]) : scaleLinear([lo, hi], [0, width]);
+		if (this.options.time === "log") SignalScales.labelled(x, SignalScales.sparse(x, x.domain()[0], x.domain()[1]), SignalScales.number);
+		if (this.options.view === "energy-decay") return {
+			x,
+			y: scaleLinear([FLOOR, 0], [height, 0])
+		};
+		const all = this.channels.flatMap((channel) => this.transform(channel)), top = Math.max(1e-9, ...all), bottom = Math.min(0, ...all);
+		return {
+			x,
+			y: scaleLinear([bottom * 1.08, top * 1.08], [height, 0]).nice(4)
+		};
+	}
+	plotMarks(ctx, { x, y }) {
+		const { mark, annotate, view } = this.options, { width } = ctx.plot, curves = this.curves(ctx, width);
+		const base = y(view === "energy-decay" ? FLOOR : 0);
+		if (view !== "energy-decay") this.rule(ctx, "zero", [0], y);
+		if (mark === "stem") {
+			this.stems(ctx, x, y, base);
+			if (annotate) this.annotate(ctx, x, y);
+			return;
+		}
+		if (mark === "area") {
+			const shape = area().x((point) => x(point[0])).y0(base).y1((point) => y(point[1]));
+			this.fill(ctx, "fill", curves, (curve) => curve.name, (curve) => shape(curve.points) ?? "", (curve) => curve.color, .22);
+		}
+		this.stroke(ctx, "curve", curves, (curve) => curve.name, (curve) => this.path(curve.points, x, y), (curve) => curve.color);
+		if (annotate) this.annotate(ctx, x, y);
+		this.timeProbe(ctx, x);
+	}
+	stems(ctx, x, y, base) {
+		const list = this.channels.flatMap((channel, c) => {
+			const values = this.transform(channel), count = Math.min(STEMS, Math.floor(ctx.plot.width / (9 * this.channels.length))), reach = channel.t.length;
+			const picks = Array.from({ length: Math.min(count, reach) }, (_, i) => this.options.time === "log" ? Math.min(reach - 1, Math.round(reach ** (i / Math.max(1, count - 1))) - 1) : Math.floor(i * reach / count));
+			return [...new Set(picks)].map((index) => ({
+				key: `${channel.name}${index}`,
+				name: channel.name,
+				t: channel.t[index],
+				value: values[index],
+				shift: (c - (this.channels.length - 1) / 2) * 4
+			}));
+		}).filter((stem) => this.options.time !== "log" || stem.t > 0);
+		const rods = ctx.marks("rods", "line", list, (stem) => stem.key).attr("stroke", (stem) => ctx.palette.color(stem.name)).attr("stroke-width", 2);
+		ctx.set(rods, {
+			x1: (stem) => x(stem.t) + stem.shift,
+			x2: (stem) => x(stem.t) + stem.shift,
+			y1: base,
+			y2: (stem) => y(stem.value)
+		}, { y2: base }, 4);
+		const heads = ctx.marks("heads", "circle", list, (stem) => stem.key).attr("fill", (stem) => ctx.palette.color(stem.name)).attr("stroke", ctx.theme.surface).attr("stroke-width", 2);
+		ctx.set(heads, {
+			cx: (stem) => x(stem.t) + stem.shift,
+			cy: (stem) => y(stem.value),
+			r: 4
+		}, {
+			cy: base,
+			r: 0
+		}, 4);
+		ctx.hover(heads, (stem) => ({
+			title: `${SignalScales.number(stem.t)} s`,
+			color: ctx.palette.color(stem.name),
+			rows: [[stem.name, SignalScales.number(stem.value)]]
+		}));
+	}
+	/** Peak for the impulse, 2% settling time for the step, RT60 by line fit for the energy decay. */
+	annotate(ctx, x, y) {
+		const channel = this.first, values = this.transform(channel), { view } = this.options, { width, height } = ctx.plot;
+		if (values.length < 3) return;
+		let label = "", index = 0;
+		if (view === "impulse") {
+			index = values.reduce((best, value, i) => Math.abs(value) > Math.abs(values[best]) ? i : best, 0);
+			label = `Peak ${SignalScales.number(values[index])} at ${SignalScales.number(channel.t[index])} s`;
+		} else if (view === "step") {
+			const final = values[values.length - 1], tolerance = Math.max(Math.abs(final) * .02, 1e-9);
+			index = values.length - 1;
+			while (index > 0 && Math.abs(values[index] - final) < tolerance) index--;
+			label = `Settles in ${SignalScales.number(channel.t[index])} s`;
+			this.rule(ctx, "band", [final + tolerance, final - tolerance], y, true);
+		} else {
+			const start = values.findIndex((value) => value <= -5), end = values.findIndex((value) => value <= -25);
+			if (start < 0 || end <= start) return;
+			const slope = (values[end] - values[start]) / (channel.t[end] - channel.t[start]);
+			index = end;
+			label = `RT60 ${SignalScales.number(-60 / slope)} s`;
+			ctx.marks("fit", "line", [0]).attr("x1", x(channel.t[start])).attr("x2", x(channel.t[end])).attr("y1", y(values[start])).attr("y2", y(values[end])).attr("stroke", ctx.theme.ink).attr("stroke-width", 2);
+		}
+		const px = x(channel.t[index]), py = y(values[index]), flip = px > width - 150;
+		if (!Number.isFinite(px)) return;
+		const dot = ctx.marks("note", "circle", [0]).attr("fill", ctx.theme.ink).attr("stroke", ctx.theme.surface).attr("stroke-width", 2);
+		ctx.set(dot, {
+			cx: px,
+			cy: py,
+			r: 4
+		}, { r: 0 });
+		ctx.text(ctx.marks("note-text", "text", [0]).attr("x", px + (flip ? -9 : 9)).attr("y", Math.max(11, Math.min(height - 5, py - 7))).attr("text-anchor", flip ? "end" : "start").text(label), 11, "ink");
+	}
+};
+export { ImpulseMark, ImpulseResponseChart, ImpulseTime, ImpulseView };

package/dist/charts/signals/LogicAnalyzerChart.js

@@ -0,0 +1,173 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SignalChart } from "./SignalChart.js";
+import { SignalSamples } from "./SignalSamples.js";
+import { SignalScales } from "./SignalScales.js";
+import { scaleBand, scaleLinear } from "d3";
+// src/charts/signals/LogicAnalyzerChart.ts
+var LogicDisplay = /* @__PURE__ */ function(LogicDisplay) {
+	LogicDisplay["Lanes"] = "lanes";
+	LogicDisplay["Bus"] = "bus";
+	LogicDisplay["Both"] = "lanes-and-bus";
+	return LogicDisplay;
+}({});
+var LogicEdge = /* @__PURE__ */ function(LogicEdge) {
+	LogicEdge["Square"] = "square";
+	LogicEdge["Slanted"] = "slanted";
+	return LogicEdge;
+}({});
+var BUS = "Bus";
+var SAMPLE_BITS = [
+	"CLK",
+	"D0",
+	"D1",
+	"D2",
+	"D3"
+];
+/** Digital timing diagram: channels as square waves, with a decoded bus lane. */
+var LogicAnalyzerChart = class extends SignalChart {
+	static meta = {
+		id: "signal-logic-analyzer",
+		name: "Logic analyzer",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Shows digital channels as timing waveforms and decodes groups of lines into bus values.",
+		tags: [
+			"timing diagram",
+			"digital",
+			"bus",
+			"protocol",
+			"wavedrom"
+		],
+		sample: (seed) => {
+			const lines = SignalSamples.noise(seed, 24, SAMPLE_BITS.length - 1);
+			const clock = Array.from({ length: 48 }, (_, i) => ({
+				t: i / 2,
+				series: "CLK",
+				value: i % 2 ? 0 : 1
+			}));
+			const bits = lines.flatMap(({ noise }, line) => noise.flatMap((step, i) => [i, i + .5].map((t) => ({
+				t,
+				series: SAMPLE_BITS[line + 1],
+				value: step + .25 * line > 0 ? 1 : 0
+			}))));
+			return [...clock, ...bits];
+		},
+		variants: {
+			display: Object.values(LogicDisplay),
+			edge: Object.values(LogicEdge),
+			shade: [true, false],
+			clock: [true, false]
+		},
+		valid: (values) => values.display !== "bus" || values.shade === true && values.edge === "square"
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			xLabel: "Time (cycles)",
+			yLabel: void 0,
+			grid: false,
+			display: "lanes",
+			edge: "square",
+			shade: true,
+			clock: true,
+			threshold: .5
+		};
+	}
+	get legended() {
+		return false;
+	}
+	runs(channel) {
+		const out = [], end = this.span[1];
+		channel.v.forEach((value, i) => {
+			const level = value > this.options.threshold ? 1 : 0, last = out[out.length - 1];
+			if (last && last.level === level) last.end = channel.t[i + 1] ?? end;
+			else out.push({
+				key: `${channel.name}${i}`,
+				start: channel.t[i],
+				end: channel.t[i + 1] ?? end,
+				level
+			});
+		});
+		return out;
+	}
+	/** Bus value for every span between changes, with the first data channel as least significant bit. */
+	words() {
+		const data = this.channels.slice(1), lines = data.length ? data : this.channels;
+		const times = [...new Set(lines.flatMap((channel) => this.runs(channel).map((run) => run.start)))].sort((a, b) => a - b);
+		const words = [];
+		times.forEach((start, i) => {
+			const value = lines.reduce((sum, channel, bit) => {
+				return sum + (this.runs(channel).find((item) => start >= item.start && start < item.end)?.level ?? 0) * 2 ** bit;
+			}, 0);
+			words.push({
+				key: `w${i}`,
+				start,
+				end: times[i + 1] ?? this.span[1],
+				value
+			});
+		});
+		return words;
+	}
+	scales(ctx) {
+		const { display } = this.options, names = this.channels.map((channel) => channel.name);
+		const rows = display === "bus" ? [BUS] : display === "lanes-and-bus" ? [...names, BUS] : names;
+		return {
+			x: scaleLinear(this.span, [0, ctx.plot.width]),
+			y: scaleBand(rows, [0, ctx.plot.height]).paddingInner(.28).paddingOuter(.06)
+		};
+	}
+	plotMarks(ctx, { x, y }) {
+		const { display, edge, shade, clock } = this.options, { height } = ctx.plot, thick = y.bandwidth(), lean = edge === "slanted" ? 4 : 0;
+		if (clock && this.channels[0]) {
+			const rising = this.runs(this.channels[0]).filter((run) => run.level === 1).map((run) => run.start);
+			const every = Math.ceil(rising.length / Math.max(1, ctx.plot.width / 20));
+			ctx.marks("clock", "line", rising.filter((_, i) => i % every === 0), (at) => at).attr("x1", (at) => x(at)).attr("x2", (at) => x(at)).attr("y1", 0).attr("y2", height).attr("stroke", ctx.theme.grid);
+		}
+		if (display !== "bus") {
+			const lanes = this.channels.map((channel) => ({
+				channel,
+				runs: this.runs(channel),
+				top: y(channel.name) ?? 0,
+				color: ctx.palette.color(channel.name)
+			}));
+			if (shade) {
+				const spans = lanes.flatMap((lane) => lane.runs.filter((run) => run.level).map((run) => ({
+					...run,
+					lane
+				})));
+				this.fill(ctx, "high", spans, (span) => span.key, (span) => `M${x(span.start) + lean} ${span.lane.top}H${x(span.end) - lean}L${x(span.end)} ${span.lane.top + thick}H${x(span.start)}Z`, (span) => span.lane.color, .2);
+			}
+			this.stroke(ctx, "wave", lanes, (lane) => lane.channel.name, (lane) => this.wave(lane.runs, lane.top, thick, lean, x), (lane) => lane.color);
+		}
+		if (display !== "lanes") this.bus(ctx, x, y(BUS) ?? 0, thick);
+		this.probe(ctx, (px) => {
+			const time = x.invert(px);
+			const rows = this.channels.map((channel) => [channel.name, this.runs(channel).find((run) => time >= run.start && time < run.end)?.level ?? 0]);
+			return {
+				x: px,
+				tip: {
+					title: `${SignalScales.number(time)}`,
+					rows
+				},
+				datum: { t: time }
+			};
+		});
+	}
+	wave(runs, top, thick, lean, x) {
+		const level = (run) => run.level ? top : top + thick;
+		const ease = (run) => Math.min(lean, (x(run.end) - x(run.start)) / 4);
+		return runs.map((run, i) => `${i ? "L" : "M"}${x(run.start) + (i ? ease(run) : 0)} ${level(run)}H${x(run.end) - (i < runs.length - 1 ? ease(run) : 0)}`).join("");
+	}
+	bus(ctx, x, top, thick) {
+		const words = this.words(), middle = top + thick / 2, tip = 3;
+		const color = ctx.palette.color(BUS);
+		this.fill(ctx, "bus", words, (word) => word.key, (word) => {
+			const a = x(word.start) + 1, b = x(word.end) - 1;
+			return `M${a} ${middle}L${a + tip} ${top}H${Math.max(a + tip, b - tip)}L${b} ${middle}L${Math.max(a + tip, b - tip)} ${top + thick}H${a + tip}Z`;
+		}, () => color, .9).attr("data-value", (word) => word.value);
+		const named = words.filter((word) => x(word.end) - x(word.start) > 15);
+		ctx.marks("bus-text", "text", named, (word) => word.key).attr("x", (word) => (x(word.start) + x(word.end)) / 2).attr("y", middle + 4).attr("text-anchor", "middle").attr("font-size", 11).attr("font-family", ctx.theme.fontFamily).attr("fill", ctx.palette.inkOn(color)).text((word) => word.value.toString(16).toUpperCase());
+	}
+};
+export { LogicAnalyzerChart, LogicDisplay, LogicEdge };