@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/signals/SignalDsp.js

@@ -0,0 +1,328 @@
+import { SignalWavelet, SignalWindow } from "./SignalEnums.js";
+// src/charts/signals/SignalDsp.ts
+var TAU = Math.PI * 2;
+var WINDOWS = {
+	[SignalWindow.Hann]: (x) => .5 - .5 * Math.cos(TAU * x),
+	[SignalWindow.Hamming]: (x) => .54 - .46 * Math.cos(TAU * x),
+	[SignalWindow.Blackman]: (x) => .42 - .5 * Math.cos(TAU * x) + .08 * Math.cos(2 * TAU * x),
+	[SignalWindow.Rectangular]: () => 1,
+	[SignalWindow.FlatTop]: (x) => .21557895 - .41663158 * Math.cos(TAU * x) + .277263158 * Math.cos(2 * TAU * x) - .083578947 * Math.cos(3 * TAU * x) + .006947368 * Math.cos(4 * TAU * x)
+};
+var mean = (values) => values.reduce((sum, value) => sum + value, 0) / (values.length || 1);
+/** Signal processing behind the charts, usable on its own: spectra, envelopes, correlation, cepstra and wavelets. */
+var SignalDsp = class {
+	static nextPow2(n) {
+		return 2 ** Math.ceil(Math.log2(Math.max(2, n)));
+	}
+	/** In-place radix-2 FFT. Both arrays must share a power-of-two length. */
+	static fft(re, im, inverse = false) {
+		const n = re.length;
+		for (let i = 1, j = 0; i < n; i++) {
+			let bit = n >> 1;
+			for (; j & bit; bit >>= 1) j ^= bit;
+			j ^= bit;
+			if (i < j) {
+				[re[i], re[j]] = [re[j], re[i]];
+				[im[i], im[j]] = [im[j], im[i]];
+			}
+		}
+		for (let size = 2; size <= n; size <<= 1) {
+			const angle = (inverse ? TAU : -TAU) / size, half = size >> 1;
+			for (let start = 0; start < n; start += size) for (let k = 0; k < half; k++) {
+				const c = Math.cos(angle * k), s = Math.sin(angle * k), a = start + k, b = a + half;
+				const tr = re[b] * c - im[b] * s, ti = re[b] * s + im[b] * c;
+				re[b] = re[a] - tr;
+				im[b] = im[a] - ti;
+				re[a] += tr;
+				im[a] += ti;
+			}
+		}
+		if (inverse) for (let i = 0; i < n; i++) {
+			re[i] /= n;
+			im[i] /= n;
+		}
+	}
+	static window(kind, n) {
+		const shape = WINDOWS[kind];
+		return Array.from({ length: n }, (_, i) => shape(i / Math.max(1, n - 1)));
+	}
+	/** Windowed, mean-removed transform padded to `size`; returns the raw bins and the window. */
+	static transform(values, kind, size) {
+		const taper = this.window(kind, values.length), centre = mean(values);
+		const re = new Array(size).fill(0), im = new Array(size).fill(0);
+		values.forEach((value, i) => {
+			re[i] = (value - centre) * taper[i];
+		});
+		this.fft(re, im);
+		return {
+			re,
+			im,
+			taper
+		};
+	}
+	/** Single-sided amplitude spectrum, normalised by the window's coherent gain. */
+	static spectrum(values, rate, kind = SignalWindow.Hann) {
+		if (values.length < 2) return {
+			freq: [],
+			mag: []
+		};
+		const size = this.nextPow2(values.length);
+		const { re, im, taper } = this.transform(values, kind, size);
+		const gain = taper.reduce((sum, w) => sum + w, 0) || 1, freq = [], mag = [];
+		for (let k = 1; k <= size / 2; k++) {
+			freq.push(k * rate / size);
+			mag.push(2 * Math.hypot(re[k], im[k]) / gain);
+		}
+		return {
+			freq,
+			mag
+		};
+	}
+	/** Power spectral density averaged over `size`-long segments; `overlap` is a fraction. */
+	static welch(values, rate, kind, size, overlap) {
+		const length = Math.min(this.nextPow2(size), this.nextPow2(values.length));
+		if (values.length < 2) return {
+			freq: [],
+			mag: [],
+			segments: 0
+		};
+		const hop = Math.max(1, Math.round(length * (1 - overlap))), sum = new Array(length / 2).fill(0);
+		let segments = 0, energy = 1;
+		for (let start = 0; start === 0 || start + length <= values.length; start += hop) {
+			const { re, im, taper } = this.transform(values.slice(start, start + length), kind, length);
+			energy = taper.reduce((total, w) => total + w * w, 0) || 1;
+			for (let k = 1; k <= length / 2; k++) sum[k - 1] += re[k] ** 2 + im[k] ** 2;
+			segments++;
+		}
+		return {
+			freq: sum.map((_, k) => (k + 1) * rate / length),
+			mag: sum.map((value) => 2 * value / (segments * energy * rate)),
+			segments
+		};
+	}
+	/** Lomb-Scargle periodogram: power at `freqs` for uneven sampling. */
+	static lombScargle(t, values, freqs) {
+		const centre = mean(values), y = values.map((value) => value - centre), variance = mean(y.map((value) => value * value)) || 1;
+		return freqs.map((freq) => {
+			const w = TAU * freq;
+			let s2 = 0, c2 = 0;
+			for (const time of t) {
+				s2 += Math.sin(2 * w * time);
+				c2 += Math.cos(2 * w * time);
+			}
+			const tau = Math.atan2(s2, c2) / (2 * w);
+			let yc = 0, ys = 0, cc = 0, ss = 0;
+			for (let i = 0; i < t.length; i++) {
+				const c = Math.cos(w * (t[i] - tau)), s = Math.sin(w * (t[i] - tau));
+				yc += y[i] * c;
+				ys += y[i] * s;
+				cc += c * c;
+				ss += s * s;
+			}
+			return (yc * yc / (cc || 1) + ys * ys / (ss || 1)) / (2 * variance);
+		});
+	}
+	/** Short-time Fourier transform with `frames` evenly spaced frames of `size` samples. */
+	static stft(values, rate, kind, size, frames, start = 0) {
+		const length = Math.min(this.nextPow2(size), this.nextPow2(values.length));
+		if (values.length < 4) return {
+			times: [],
+			freqs: [],
+			mags: []
+		};
+		const span = Math.max(0, values.length - length), count = span ? frames : 1;
+		const freqs = Array.from({ length: length / 2 }, (_, k) => (k + 1) * rate / length), times = [], mags = [];
+		for (let f = 0; f < count; f++) {
+			const from = Math.round(f * span / Math.max(1, count - 1));
+			const { re, im, taper } = this.transform(values.slice(from, from + length), kind, length);
+			const gain = taper.reduce((sum, w) => sum + w, 0) || 1;
+			times.push(start + (from + length / 2) / rate);
+			mags.push(freqs.map((_, k) => 2 * Math.hypot(re[k + 1], im[k + 1]) / gain));
+		}
+		return {
+			times,
+			freqs,
+			mags
+		};
+	}
+	/** Amplitude envelope and instantaneous phase from the analytic signal. */
+	static hilbert(values) {
+		const size = this.nextPow2(values.length), centre = mean(values);
+		const re = new Array(size).fill(0), im = new Array(size).fill(0);
+		values.forEach((value, i) => {
+			re[i] = value - centre;
+		});
+		this.fft(re, im);
+		for (let k = 1; k < size; k++) {
+			const gain = k < size / 2 ? 2 : k === size / 2 ? 1 : 0;
+			re[k] *= gain;
+			im[k] *= gain;
+		}
+		this.fft(re, im, true);
+		return {
+			envelope: values.map((_, i) => Math.hypot(re[i], im[i])),
+			phase: values.map((_, i) => Math.atan2(im[i], re[i]))
+		};
+	}
+	/** Root-mean-square over a centred sliding window of `span` samples. */
+	static rms(values, span) {
+		const half = Math.max(1, Math.round(span / 2)), squares = [0];
+		for (const value of values) squares.push(squares[squares.length - 1] + value * value);
+		return values.map((_, i) => {
+			const a = Math.max(0, i - half), b = Math.min(values.length, i + half);
+			return Math.sqrt((squares[b] - squares[a]) / (b - a));
+		});
+	}
+	/** Instant-attack, exponential-release peak follower. `release` is the decay per sample. */
+	static follow(values, release) {
+		let level = 0;
+		return values.map((value) => level = Math.max(Math.abs(value), level * release));
+	}
+	/** Centred moving average of `span` samples. */
+	static smooth(values, span) {
+		const half = Math.max(1, Math.round(span / 2)), running = [0];
+		for (const value of values) running.push(running[running.length - 1] + value);
+		return values.map((_, i) => {
+			const a = Math.max(0, i - half), b = Math.min(values.length, i + half);
+			return (running[b] - running[a]) / (b - a);
+		});
+	}
+	/** Normalised correlation of `a` with `b` for lags `-reach..reach`. */
+	static correlate(a, b, reach) {
+		const n = Math.min(a.length, b.length), ma = mean(a.slice(0, n)), mb = mean(b.slice(0, n));
+		let ea = 0, eb = 0;
+		for (let i = 0; i < n; i++) {
+			ea += (a[i] - ma) ** 2;
+			eb += (b[i] - mb) ** 2;
+		}
+		const norm = Math.sqrt(ea * eb) || 1, out = [];
+		for (let lag = -reach; lag <= reach; lag++) {
+			let sum = 0;
+			for (let i = Math.max(0, -lag); i < n && i + lag < n; i++) sum += (a[i] - ma) * (b[i + lag] - mb);
+			out.push({
+				lag,
+				value: sum / norm
+			});
+		}
+		return out;
+	}
+	/** Autocorrelation at lags `0..reach`. */
+	static autocorrelation(values, reach) {
+		return this.correlate(values, values, reach).slice(reach).map((point) => point.value);
+	}
+	/** Partial autocorrelation at lags `0..reach`, by Durbin-Levinson recursion. */
+	static partial(acf) {
+		const out = [1];
+		let previous = [];
+		for (let k = 1; k < acf.length; k++) {
+			const top = acf[k] - previous.reduce((sum, phi, j) => sum + phi * acf[k - 1 - j], 0);
+			const bottom = 1 - previous.reduce((sum, phi, j) => sum + phi * acf[j + 1], 0);
+			const reflect = Math.abs(bottom) < 1e-9 ? 0 : top / bottom;
+			previous = [...previous.map((phi, j) => phi - reflect * previous[previous.length - 1 - j]), reflect];
+			out.push(reflect);
+		}
+		return out;
+	}
+	/** Real cepstrum, or the power cepstrum (its squared magnitude, on the log power spectrum). */
+	static cepstrum(values, power) {
+		if (values.length < 4) return [];
+		const size = this.nextPow2(values.length);
+		const { re, im } = this.transform(values, SignalWindow.Hann, size);
+		const log = re.map((r, k) => Math.log(Math.hypot(r, im[k]) ** (power ? 2 : 1) + 1e-9)), zero = new Array(size).fill(0);
+		this.fft(log, zero, true);
+		return log.slice(0, size / 2).map((value, i) => power ? value ** 2 + zero[i] ** 2 : value);
+	}
+	/** Continuous wavelet transform in the frequency domain (Torrence and Compo), one inverse FFT per scale. */
+	static wavelet(values, rate, kind, scales = 48) {
+		const n = values.length, dt = 1 / rate, size = this.nextPow2(n * 2), centre = mean(values);
+		if (n < 8) return {
+			periods: [],
+			re: [],
+			im: [],
+			coi: []
+		};
+		const re0 = new Array(size).fill(0), im0 = new Array(size).fill(0);
+		values.forEach((value, i) => {
+			re0[i] = value - centre;
+		});
+		this.fft(re0, im0);
+		const omega = re0.map((_, k) => TAU * (k <= size / 2 ? k : k - size) / (size * dt));
+		const fourier = {
+			[SignalWavelet.Morlet]: 4 * Math.PI / (6 + Math.sqrt(38)),
+			[SignalWavelet.Ricker]: TAU / Math.sqrt(2.5),
+			[SignalWavelet.Paul]: 4 * Math.PI / 9
+		}[kind];
+		const shape = {
+			[SignalWavelet.Morlet]: (s) => s > 0 ? Math.exp(-((s - 6) ** 2) / 2) * .751 : 0,
+			[SignalWavelet.Ricker]: (s) => s * s * Math.exp(-(s * s) / 2) * .867,
+			[SignalWavelet.Paul]: (s) => s > 0 ? s ** 4 * Math.exp(-s) * .112 : 0
+		}[kind];
+		const least = 2 * dt, most = n * dt / 3;
+		const periods = Array.from({ length: scales }, (_, i) => least * (most / least) ** (i / Math.max(1, scales - 1)));
+		const re = [], im = [];
+		for (const period of periods) {
+			const scale = period / fourier, norm = Math.sqrt(TAU * scale / dt);
+			const fr = re0.map((value, k) => value * shape(scale * omega[k]) * norm), fi = im0.map((value, k) => value * shape(scale * omega[k]) * norm);
+			this.fft(fr, fi, true);
+			re.push(fr.slice(0, n));
+			im.push(fi.slice(0, n));
+		}
+		const fold = fourier * (kind === SignalWavelet.Paul ? Math.SQRT1_2 : Math.SQRT2);
+		return {
+			periods,
+			re,
+			im,
+			coi: values.map((_, i) => Math.min(i, n - 1 - i) * dt * fold)
+		};
+	}
+	/** Min, max and RMS per bucket, so long traces draw at screen resolution without losing peaks. */
+	static buckets(t, values, count) {
+		const n = Math.max(1, Math.min(Math.floor(count), values.length)), out = [];
+		for (let b = 0; b < n; b++) {
+			const from = Math.floor(b * values.length / n), to = Math.max(from + 1, Math.floor((b + 1) * values.length / n));
+			let min = Infinity, max = -Infinity, sum = 0, lowest = from, highest = from;
+			for (let i = from; i < to; i++) {
+				if (values[i] < min) {
+					min = values[i];
+					lowest = i;
+				}
+				if (values[i] > max) {
+					max = values[i];
+					highest = i;
+				}
+				sum += values[i] ** 2;
+			}
+			out.push({
+				t: t[from],
+				min,
+				max,
+				rms: Math.sqrt(sum / (to - from)),
+				rising: lowest <= highest
+			});
+		}
+		return out;
+	}
+	/** Index where the short-term to long-term energy ratio first exceeds `threshold`, or -1. */
+	static staLta(values, short, long, threshold, from = 0) {
+		const energy = [0];
+		for (const value of values) energy.push(energy[energy.length - 1] + value * value);
+		for (let i = Math.max(from, long + short); i < values.length - short; i++) if ((energy[i + short] - energy[i]) / short > threshold * ((energy[i] - energy[i - long]) / long || 1e-12)) return i;
+		return -1;
+	}
+	static decibel(value, reference = 1, floor = -120) {
+		return value > 0 && reference > 0 ? Math.max(floor, 20 * Math.log10(value / reference)) : floor;
+	}
+	/** Linear value at `at` in sorted `t`. */
+	static interpolate(t, values, at) {
+		let lo = 0, hi = t.length - 1;
+		if (hi < 0) return 0;
+		while (hi - lo > 1) {
+			const mid = lo + hi >> 1;
+			if (t[mid] <= at) lo = mid;
+			else hi = mid;
+		}
+		const span = t[hi] - t[lo];
+		return span > 0 ? values[lo] + (values[hi] - values[lo]) * Math.max(0, Math.min(1, (at - t[lo]) / span)) : values[lo];
+	}
+};
+export { SignalDsp };

package/dist/charts/signals/SignalEnums.js

@@ -0,0 +1,32 @@
+// src/charts/signals/SignalEnums.ts
+var SignalWindow = /* @__PURE__ */ function(SignalWindow) {
+	SignalWindow["Hann"] = "hann";
+	SignalWindow["Hamming"] = "hamming";
+	SignalWindow["Blackman"] = "blackman";
+	SignalWindow["Rectangular"] = "rectangular";
+	SignalWindow["FlatTop"] = "flat-top";
+	return SignalWindow;
+}({});
+var SignalFrequencyScale = /* @__PURE__ */ function(SignalFrequencyScale) {
+	SignalFrequencyScale["Linear"] = "linear";
+	SignalFrequencyScale["Log"] = "log";
+	SignalFrequencyScale["Mel"] = "mel";
+	return SignalFrequencyScale;
+}({});
+var SignalAmplitude = /* @__PURE__ */ function(SignalAmplitude) {
+	SignalAmplitude["Decibel"] = "decibel";
+	SignalAmplitude["Linear"] = "linear";
+	return SignalAmplitude;
+}({});
+var SignalLayout = /* @__PURE__ */ function(SignalLayout) {
+	SignalLayout["Lanes"] = "lanes";
+	SignalLayout["Overlay"] = "overlay";
+	return SignalLayout;
+}({});
+var SignalWavelet = /* @__PURE__ */ function(SignalWavelet) {
+	SignalWavelet["Morlet"] = "morlet";
+	SignalWavelet["Ricker"] = "ricker";
+	SignalWavelet["Paul"] = "paul";
+	return SignalWavelet;
+}({});
+export { SignalAmplitude, SignalFrequencyScale, SignalLayout, SignalWavelet, SignalWindow };

package/dist/charts/signals/SignalRaster.js

@@ -0,0 +1,36 @@
+// src/charts/signals/SignalRaster.ts
+var LEVELS = 28;
+/** Paints a value field as one path per colour level, so large rasters stay a handful of DOM nodes. */
+var SignalRaster = class {
+	static paint(ctx, name, cells, color) {
+		const groups = /* @__PURE__ */ new Map();
+		for (const { x, y, width, height, level } of cells) {
+			const step = Math.round(level * LEVELS);
+			if (!groups.has(step)) groups.set(step, []);
+			groups.get(step).push(`M${x.toFixed(1)} ${y.toFixed(1)}h${width.toFixed(1)}v${height.toFixed(1)}h${(-width).toFixed(1)}z`);
+		}
+		const data = [...groups].map(([step, parts]) => ({
+			step,
+			d: parts.join("")
+		}));
+		const paths = ctx.marks(name, "path", data, (datum) => datum.step).attr("fill", (datum) => color(datum.step / LEVELS)).attr("shape-rendering", "crispEdges");
+		ctx.set(paths, {
+			d: (datum) => datum.d,
+			opacity: 1
+		}, { opacity: 0 });
+	}
+	/** Vertical colour key inside the plot's right edge; `lo` and `hi` label its ends. */
+	static ramp(ctx, x, color, lo, hi) {
+		const { height } = ctx.plot, count = 32, stops = Array.from({ length: count }, (_, i) => i), band = 10, top = 14, bottom = height - 14;
+		const size = (bottom - top) / count;
+		ctx.marks("ramp", "rect", stops, (stop) => stop).attr("x", x).attr("width", band).attr("y", (stop) => bottom - (stop + 1) * size).attr("height", size + .5).attr("fill", (stop) => color(stop / 31)).attr("shape-rendering", "crispEdges");
+		ctx.text(ctx.marks("ramp-text", "text", [{
+			text: hi,
+			y: 9
+		}, {
+			text: lo,
+			y: height - 2
+		}], (item) => item.y).attr("x", x + band / 2).attr("y", (item) => item.y).attr("text-anchor", "middle").text((item) => item.text), 10, "muted");
+	}
+};
+export { SignalRaster };

package/dist/charts/signals/SignalSamples.js

@@ -0,0 +1,107 @@
+import { SampleData } from "../../data/SampleData.js";
+// src/charts/signals/SignalSamples.ts
+var TAU = Math.PI * 2;
+/** Reshapes `SampleData` random walks into repeatable signals; only the step noise and phases come from the walk. */
+var SignalSamples = class {
+	/** Zero-mean, unit-variance noise per series, from the steps of a random walk. */
+	static noise(seed, samples, channels) {
+		const rows = SampleData.timeSeries(seed, samples + 1, channels);
+		return [...new Set(rows.map((row) => String(row.series)))].map((name) => {
+			const walk = rows.filter((row) => row.series === name).map((row) => +row.value);
+			const steps = walk.slice(1).map((value, i) => value - walk[i]), mean = steps.reduce((sum, step) => sum + step, 0) / steps.length;
+			const deviation = Math.sqrt(steps.reduce((sum, step) => sum + (step - mean) ** 2, 0) / steps.length) || 1;
+			return {
+				name,
+				noise: steps.map((step) => (step - mean) / deviation)
+			};
+		});
+	}
+	static rows(seed, samples, channels, rate, shape) {
+		return this.noise(seed, samples, channels).flatMap(({ name, noise }, channel) => {
+			const phase = Math.abs(noise[0]) % TAU;
+			return noise.map((step, i) => ({
+				t: +(i / rate).toFixed(6),
+				series: name,
+				value: +shape(i / rate, channel, step, phase).toFixed(5)
+			}));
+		});
+	}
+	/** Plucked notes with harmonics, in a phrase: the demo for waveforms and spectra. */
+	static notes(seed = 1, samples = 2048, channels = 2, rate = 8e3) {
+		const duration = samples / rate, starts = [
+			0,
+			.22,
+			.47,
+			.68
+		].map((start) => start * duration);
+		return this.rows(seed, samples, channels, rate, (t, channel, noise, phase) => {
+			const note = starts.reduce((held, start, i) => t >= start ? i : held, 0), since = t - starts[note];
+			const pitch = (220 + 45 * channel) * [
+				1,
+				1.5,
+				1.25,
+				2
+			][note];
+			const tone = Math.sin(TAU * pitch * t + phase) + .5 * Math.sin(TAU * 2 * pitch * t) + .25 * Math.sin(TAU * 3 * pitch * t + phase);
+			return (.82 - channel * .22) * Math.exp(-since * 14 / duration * .5) * Math.min(1, since * 400) * tone * .58 + .002 * noise;
+		});
+	}
+	/** A rising chirp, a steady tone and a click: shows off time-frequency views. */
+	static chirp(seed = 1, samples = 4096, channels = 1, rate = 8e3) {
+		const duration = samples / rate;
+		return this.rows(seed, samples, channels, rate, (t, channel, noise, phase) => {
+			const x = t / duration, sweep = 150 * t + 1500 * t * t / (2 * duration);
+			const click = Math.exp(-(((x - .72) / .004) ** 2)) * Math.sin(TAU * 2600 * t);
+			return .7 * Math.sin(TAU * sweep + phase + channel) * Math.sin(Math.PI * x) ** .5 + .28 * Math.sin(TAU * 900 * t) * (x > .15 && x < .55 ? 1 : 0) + .5 * click + .002 * noise;
+		});
+	}
+	/** A pulse train with formant-like harmonics: a voiced sound with a clear pitch. */
+	static voiced(seed = 1, samples = 2048, channels = 1, rate = 8e3) {
+		const pitch = 142;
+		return this.rows(seed, samples, channels, rate, (t, channel, noise, phase) => {
+			let sum = 0;
+			for (let k = 1; k <= 36; k++) {
+				const f = k * pitch * (1 + channel * .2);
+				if (f < rate / 2) sum += (Math.exp(-(((f - 650) / 420) ** 2)) + .45 * Math.exp(-(((f - 1700) / 520) ** 2)) + .04) * Math.sin(TAU * f * t + phase * k);
+			}
+			return sum * .5 + .01 * noise;
+		});
+	}
+	/** Rössler attractor sampled from a noise-chosen start; `value` per series holds x, y and z. */
+	static attractor(seed = 1, samples = 1600, channels = 2) {
+		const [{ noise }] = this.noise(seed, 8, 1);
+		let [x, y, z] = [
+			1 + noise[0] * .3,
+			1 + noise[1] * .3,
+			.1
+		];
+		const dt = .03, trail = [];
+		const flow = (a, b, c) => [
+			-b - c,
+			a + .2 * b,
+			.2 + c * (a - 5.7)
+		];
+		for (let i = 0; i < samples + 600; i++) {
+			const k1 = flow(x, y, z), k2 = flow(x + dt / 2 * k1[0], y + dt / 2 * k1[1], z + dt / 2 * k1[2]);
+			const k3 = flow(x + dt / 2 * k2[0], y + dt / 2 * k2[1], z + dt / 2 * k2[2]), k4 = flow(x + dt * k3[0], y + dt * k3[1], z + dt * k3[2]);
+			x += dt / 6 * (k1[0] + 2 * k2[0] + 2 * k3[0] + k4[0]);
+			y += dt / 6 * (k1[1] + 2 * k2[1] + 2 * k3[1] + k4[1]);
+			z += dt / 6 * (k1[2] + 2 * k2[2] + 2 * k3[2] + k4[2]);
+			if (i >= 600) trail.push([
+				x,
+				y,
+				z
+			]);
+		}
+		return [
+			"x",
+			"y",
+			"z"
+		].slice(0, channels).flatMap((series, axis) => trail.map((point, i) => ({
+			t: +(i * dt).toFixed(3),
+			series,
+			value: +point[axis].toFixed(4)
+		})));
+	}
+};
+export { SignalSamples };

package/dist/charts/signals/SignalScales.js

@@ -0,0 +1,56 @@
+import { SignalFrequencyScale } from "./SignalEnums.js";
+import { format, scaleLinear, scaleLog, scaleSymlog } from "d3";
+// src/charts/signals/SignalScales.ts
+var compact = format(".3~s");
+var plain = format(".3~r");
+/** Scale helpers for hertz, decibels and hand-picked ticks. The axis reads `ticks` and `label` from the scale. */
+var SignalScales = class {
+	/** Pins the tick values and their text on a scale. */
+	static labelled(scale, ticks, text) {
+		return Object.assign(scale, {
+			ticks: () => [...ticks],
+			label: text
+		});
+	}
+	static hertz(value) {
+		return value >= 1e3 ? `${+(value / 1e3).toFixed(1)}k` : `${+value.toFixed(1)}`;
+	}
+	static number(value) {
+		const size = Math.abs(value);
+		if (size === 0) return "0";
+		if (size < .001) return value.toExponential(1);
+		return (size >= 1e4 ? compact(value) : plain(value)).replace("−", "-");
+	}
+	/** Round 1-2-5 ticks at least `gap` pixels apart; suits log and mel axes, whose ticks would otherwise crowd. */
+	static sparse(scale, lo, hi, gap = 44) {
+		const out = [];
+		let last = NaN;
+		const least = Math.max(lo, hi * 1e-5);
+		for (let power = Math.floor(Math.log10(least)); power <= Math.ceil(Math.log10(hi)); power++) for (const step of [
+			1,
+			2,
+			5
+		]) {
+			const tick = step * 10 ** power, px = scale(tick);
+			if (tick < lo || tick > hi || Math.abs(px - last) < gap) continue;
+			out.push(tick);
+			last = px;
+		}
+		return out;
+	}
+	static frequency(kind, [lo, hi], range) {
+		const span = Math.abs(range[1] - range[0]);
+		if (kind === SignalFrequencyScale.Linear) {
+			const linear = scaleLinear([lo, Math.max(hi, lo + 1)], range);
+			return this.labelled(linear, linear.ticks(Math.max(2, Math.floor(span / 56))), this.hertz);
+		}
+		const top = Math.max(hi, 10);
+		if (kind === SignalFrequencyScale.Mel) {
+			const scale = scaleSymlog([0, top], range).constant(700);
+			return this.labelled(scale, [0, ...this.sparse(scale, 200, top)], this.hertz);
+		}
+		const bottom = Math.max(lo, .001), scale = scaleLog([bottom, Math.max(top, bottom * 10)], range);
+		return this.labelled(scale, this.sparse(scale, bottom, Math.max(top, bottom * 10)), this.hertz);
+	}
+};
+export { SignalScales };

package/dist/charts/signals/SpectralChart.js

@@ -0,0 +1,23 @@
+import { SignalChart } from "./SignalChart.js";
+import { SignalFrequencyScale } from "./SignalEnums.js";
+import { SignalScales } from "./SignalScales.js";
+// src/charts/signals/SpectralChart.ts
+/** Base for charts with frequency along x. */
+var SpectralChart = class extends SignalChart {
+	defaults() {
+		return {
+			...super.defaults(),
+			xLabel: "Frequency (Hz)",
+			yLabel: "Level (dB)",
+			frequency: SignalFrequencyScale.Linear
+		};
+	}
+	/** Frequency scale fitted to the positive `freqs`. */
+	frequencyAxis(freqs, width) {
+		const positive = freqs.filter((freq) => freq > 0);
+		if (!positive.length) return SignalScales.frequency(this.options.frequency, [1, 10], [0, width]);
+		const lo = this.options.frequency === SignalFrequencyScale.Log ? positive[0] : 0;
+		return SignalScales.frequency(this.options.frequency, [lo, positive[positive.length - 1]], [0, width]);
+	}
+};
+export { SpectralChart };