@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/radial/SpiralChart.js

@@ -0,0 +1,188 @@
+import { DataShape, ScaleKind } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { Polar, TAU } from "./Polar.js";
+import { PolarBase, polarMeta } from "./PolarBase.js";
+import { PolarDirection, TimeSpiralGrowth, TimeSpiralMark } from "./radialEnums.js";
+import { areaRadial, extent, lineRadial, scaleLinear } from "d3";
+// src/charts/radial/SpiralChart.ts
+var DAY = 864e5;
+var HOLE = .14;
+var stamp = new Intl.DateTimeFormat("en", {
+	month: "short",
+	day: "numeric",
+	timeZone: "UTC"
+});
+/** Reveal periodic patterns in long series: each turn is one period, so cycles line up along spokes. */
+var SpiralChart = class extends PolarBase {
+	static meta = {
+		...polarMeta,
+		id: "spiral",
+		name: "Time spiral",
+		shape: DataShape.Table,
+		description: "Coils a long time series so that each turn is one period and repeating patterns align along the spokes.",
+		tags: [
+			"time spiral",
+			"periodic",
+			"seasonality"
+		],
+		sample: (seed) => SampleData.timeSeries(seed, 180, 1),
+		variants: {
+			mark: [
+				TimeSpiralMark.Ribbon,
+				TimeSpiralMark.Bars,
+				TimeSpiralMark.Heat,
+				TimeSpiralMark.Dots,
+				TimeSpiralMark.Line
+			],
+			period: [
+				30,
+				14,
+				60
+			],
+			growth: [TimeSpiralGrowth.Archimedean, TimeSpiralGrowth.Logarithmic],
+			direction: [PolarDirection.Outward, PolarDirection.Inward]
+		}
+	};
+	defaults() {
+		return {
+			date: "date",
+			value: "value",
+			mark: TimeSpiralMark.Ribbon,
+			period: 30,
+			growth: TimeSpiralGrowth.Archimedean,
+			direction: PolarDirection.Outward
+		};
+	}
+	readings() {
+		const { data, date, value, period } = this.options;
+		const sums = /* @__PURE__ */ new Map();
+		for (const row of Polar.rows(data)) {
+			const t = Polar.time(row[date]), v = Polar.number(row[value]);
+			if (t !== null && v !== null) sums.set(t, (sums.get(t) ?? 0) + v);
+		}
+		const points = [...sums].sort((a, b) => a[0] - b[0]);
+		const first = points[0]?.[0] ?? 0, last = points[points.length - 1]?.[0] ?? 1;
+		return points.map(([t, v]) => ({
+			t,
+			value: v,
+			date: stamp.format(t),
+			angle: (t - first) / (period * DAY) * TAU,
+			u: last > first ? (t - first) / (last - first) : 0
+		}));
+	}
+	drawRadial(ctx, frame) {
+		const disc = this.disc(ctx, frame);
+		const { period, growth, direction, mark } = this.options;
+		const readings = this.readings();
+		const turns = Math.max(1, (readings[readings.length - 1]?.angle ?? TAU) / TAU);
+		const hole = disc.radius * HOLE;
+		const log = growth === TimeSpiralGrowth.Logarithmic;
+		const edge = log ? disc.radius * (1 - .5 * (1 - (hole / disc.radius) ** (1 / turns))) : disc.radius - (disc.radius - hole) / (2 * turns);
+		const r = (u) => {
+			const at = direction === PolarDirection.Outward ? u : 1 - u;
+			return log ? hole * (edge / hole) ** at : hole + (edge - hole) * at;
+		};
+		const pitch = (u) => {
+			const step = 1 / turns;
+			return u + step <= 1 ? Math.abs(r(u + step) - r(u)) : Math.abs(r(u) - r(u - step));
+		};
+		const guide = lineRadial().angle((d) => d.angle).radius((d) => r(d.u));
+		const path = ctx.marks("guide", "path", mark === TimeSpiralMark.Heat || !readings.length ? [] : [readings], () => "guide").attr("fill", "none").attr("stroke", ctx.theme.grid);
+		ctx.set(path, { d: (d) => guide(d) }, { d: (d) => guide(d) });
+		this.spokes(disc, [
+			0,
+			.25,
+			.5,
+			.75
+		].map((turn) => turn * TAU), hole, disc.radius);
+		this.rimLabels(disc, [
+			0,
+			.25,
+			.5,
+			.75
+		].map((turn) => ({
+			angle: turn * TAU,
+			text: `day ${1 + Math.round(turn * period)}`
+		})), "rim-labels", "muted");
+		this.paintMark(disc, readings, r, pitch);
+		this.dateLabels(disc, readings, r);
+	}
+	paintMark(disc, readings, r, pitch) {
+		const { ctx } = disc;
+		const { mark, value, period } = this.options;
+		const values = readings.map((d) => d.value);
+		const color = ctx.palette.color(value);
+		const zeroed = Polar.scale(ScaleKind.Linear, values, [0, 1]);
+		const [low = 0, high = 1] = extent(values);
+		const heat = scaleLinear([low, high > low ? high : low + 1], [0, 1]);
+		const tip = (d) => ({
+			title: d.date,
+			color,
+			rows: [[value, d.value]]
+		});
+		const half = readings.length > 1 ? Math.PI * (readings[1].t - readings[0].t) / (period * DAY) : TAU / 48;
+		const ribbon = mark === TimeSpiralMark.Ribbon ? [readings] : [];
+		const band = (flat) => areaRadial().angle((d) => d.angle).innerRadius((d) => r(d.u) - (flat ? .2 : pitch(d.u) * .46 * zeroed(d.value))).outerRadius((d) => r(d.u) + (flat ? .2 : pitch(d.u) * .46 * zeroed(d.value)));
+		const ribbons = ctx.marks("ribbon", "path", ribbon, () => "ribbon").attr("fill", color);
+		ctx.set(ribbons, { d: (d) => band(false)(d) }, { d: (d) => band(true)(d) });
+		ctx.hover(ribbons, (d) => ({
+			title: `${d[0]?.date} – ${d[d.length - 1]?.date}`,
+			color
+		}));
+		const wobble = lineRadial().angle((d) => d.angle).radius((d) => r(d.u) + pitch(d.u) * .9 * (heat(d.value) - .5));
+		const lines = ctx.marks("wave", "path", mark === TimeSpiralMark.Line ? [readings] : [], () => "wave").attr("fill", "none").attr("stroke", color).attr("stroke-width", 2).attr("stroke-linejoin", "round");
+		ctx.set(lines, { d: (d) => wobble(d) }, { d: (d) => wobble(d) });
+		ctx.drawOn(lines);
+		this.wedges(disc, mark === TimeSpiralMark.Bars ? readings.map((d) => ({
+			key: `${d.t}`,
+			a0: d.angle - half,
+			a1: d.angle + half,
+			r0: r(d.u) - pitch(d.u) * .46,
+			r1: r(d.u) - pitch(d.u) * .46 + pitch(d.u) * .92 * zeroed(d.value),
+			fill: color,
+			tip: tip(d)
+		})) : mark === TimeSpiralMark.Heat ? readings.map((d) => ({
+			key: `${d.t}`,
+			a0: d.angle - half,
+			a1: d.angle + half,
+			r0: r(d.u) - pitch(d.u) * .48,
+			r1: r(d.u) + pitch(d.u) * .48,
+			fill: ctx.palette.sequential(heat(d.value)),
+			tip: {
+				...tip(d),
+				color: ctx.palette.sequential(heat(d.value))
+			}
+		})) : [], {
+			corner: 0,
+			gap: mark === TimeSpiralMark.Heat ? .6 : 1,
+			stagger: 2
+		});
+		const dots = ctx.marks("dots", "circle", mark === TimeSpiralMark.Dots ? readings : [], (d) => d.t).attr("fill", color).attr("fill-opacity", .8);
+		const area = (d) => Math.min(pitch(d.u) * .5, 2 + 5 * Math.sqrt(zeroed(d.value)));
+		ctx.set(dots, {
+			cx: (d) => Polar.point(d.angle, r(d.u))[0],
+			cy: (d) => Polar.point(d.angle, r(d.u))[1],
+			r: area
+		}, {
+			cx: (d) => Polar.point(d.angle, r(d.u))[0],
+			cy: (d) => Polar.point(d.angle, r(d.u))[1],
+			r: 0
+		}, 2);
+		ctx.hover(dots, tip);
+	}
+	/** The date at the start of each turn, spaced so they never touch. */
+	dateLabels(disc, readings, r) {
+		const { ctx } = disc;
+		const starts = readings.filter((d, i) => !i || Math.floor(d.angle / TAU) !== Math.floor(readings[i - 1].angle / TAU));
+		const kept = [];
+		for (const d of starts) if (kept.every((other) => Math.abs(r(other.u) - r(d.u)) >= 14)) kept.push(d);
+		const text = ctx.marks("dates", "text", kept, (d) => d.t).attr("paint-order", "stroke").attr("stroke", ctx.theme.surface).attr("stroke-width", 3);
+		ctx.text(text, 10, "secondary").attr("text-anchor", "end").attr("dx", -3).text((d) => d.date);
+		const at = {
+			x: (d) => Polar.point(d.angle, r(d.u))[0],
+			y: (d) => Polar.point(d.angle, r(d.u))[1] + 3
+		};
+		ctx.set(text, at, at);
+	}
+};
+export { SpiralChart };

package/dist/charts/radial/SunburstBar.js

@@ -0,0 +1,140 @@
+import { DataShape } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { TAU } from "./Polar.js";
+import { PolarBase, polarMeta } from "./PolarBase.js";
+import { PolarSort, SunburstBarLevels, SunburstBarSizing } from "./radialEnums.js";
+import { hierarchy, max } from "d3";
+// src/charts/radial/SunburstBar.ts
+var CORE = .52;
+var TINT = .72;
+/** A hierarchy whose rings show its branches and whose outer bars compare the leaves across them. */
+var SunburstBar = class extends PolarBase {
+	static meta = {
+		...polarMeta,
+		id: "sunburst-bar",
+		name: "Sunburst bar chart",
+		shape: DataShape.Hierarchy,
+		description: "Rings of branches carry radial bars for their leaves, joining a tree structure with a value comparison.",
+		tags: [
+			"hierarchical bar",
+			"sunburst",
+			"tree"
+		],
+		sample: (seed) => SampleData.tree(seed, 3, 4),
+		variants: {
+			sizing: [SunburstBarSizing.Bars, SunburstBarSizing.Partition],
+			sort: [PolarSort.Data, PolarSort.Descending],
+			levels: [SunburstBarLevels.All, SunburstBarLevels.Top],
+			hole: [.16, .3],
+			labels: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			sizing: SunburstBarSizing.Bars,
+			sort: PolarSort.Data,
+			levels: SunburstBarLevels.All,
+			hole: .16,
+			labels: true
+		};
+	}
+	table() {
+		const tree = this.options.data;
+		if (!tree) return {
+			columns: [],
+			rows: []
+		};
+		return {
+			columns: ["path", "value"],
+			rows: hierarchy(tree).leaves().map((leaf) => [leaf.ancestors().reverse().map((d) => d.data.name).join(" / "), leaf.data.value ?? null])
+		};
+	}
+	/** Angular extent of every node: leaves are laid out in order, parents span their children. */
+	layout(root) {
+		const leaves = root.leaves(), branches = root.children ?? [root];
+		const equal = this.options.sizing === SunburstBarSizing.Bars;
+		const weight = (leaf) => equal ? 1 : Math.max(0, leaf.value ?? 0);
+		const breaks = branches.length > 1 ? branches.length : 0;
+		const total = leaves.reduce((sum, leaf) => sum + weight(leaf), 0) || 1;
+		const gap = equal ? TAU / (leaves.length + breaks) : TAU * .012;
+		const scale = (TAU - gap * breaks) / total;
+		const spans = /* @__PURE__ */ new Map();
+		let cursor = 0, branch;
+		for (const leaf of leaves) {
+			const owner = branches.find((b) => b === leaf || leaf.ancestors().includes(b));
+			if (branch && owner !== branch) cursor += gap;
+			branch = owner;
+			const a1 = cursor + weight(leaf) * scale;
+			spans.set(leaf, {
+				a0: cursor,
+				a1
+			});
+			cursor = a1;
+		}
+		root.eachAfter((node) => {
+			if (!node.children) return;
+			const parts = node.children.map((child) => spans.get(child));
+			spans.set(node, {
+				a0: parts[0].a0,
+				a1: parts[parts.length - 1].a1
+			});
+		});
+		return spans;
+	}
+	drawRadial(ctx, frame) {
+		const disc = this.disc(ctx, frame);
+		const { sizing, sort, levels, hole, labels } = this.options;
+		const tree = this.options.data;
+		if (!tree) return;
+		const root = hierarchy(tree, (d) => d.children).sum((d) => d.children?.length ? 0 : Math.max(0, d.value ?? 0));
+		root.children?.forEach((node) => ctx.palette.color(node.data.name));
+		if (sort === PolarSort.Descending) root.sort((a, b) => (b.value ?? 0) - (a.value ?? 0));
+		const spans = this.layout(root);
+		const inner = disc.radius * hole, core = disc.radius * CORE;
+		const branchOf = (node) => node.ancestors().find((d) => d.depth === 1) ?? root;
+		const color = (node) => ctx.palette.color(branchOf(node).data.name);
+		const depth = levels === SunburstBarLevels.All ? Math.max(1, root.height - 1) : 1;
+		const thick = (core - inner) / depth;
+		const rings = root.descendants().filter((node) => node.depth >= 1 && node.depth <= depth && node.children);
+		const leaves = root.leaves(), peak = max(leaves, (leaf) => leaf.value ?? 0) || 1;
+		const bars = sizing === SunburstBarSizing.Bars;
+		const wedges = [...rings.map((node) => ({
+			key: node.ancestors().map((d) => d.data.name).join("/"),
+			...spans.get(node),
+			r0: inner + (node.depth - 1) * thick + 1,
+			r1: inner + node.depth * thick - 1,
+			fill: color(node),
+			opacity: node.depth === 1 ? 1 : TINT,
+			tip: {
+				title: node.data.name,
+				color: color(node),
+				rows: [["Total", node.value ?? 0]]
+			}
+		})), ...leaves.map((node) => ({
+			key: node.ancestors().map((d) => d.data.name).join("/"),
+			...spans.get(node),
+			r0: core + 1,
+			r1: bars ? core + 1 + (node.value ?? 0) / peak * (disc.radius - core - 1) : disc.radius,
+			fill: color(node),
+			tip: {
+				title: node.ancestors().reverse().slice(1).map((d) => d.data.name).join(" / ") || node.data.name,
+				color: color(node),
+				rows: [["Value", node.value ?? 0]]
+			}
+		}))];
+		this.wedges(disc, wedges, {
+			corner: 2,
+			stagger: 4
+		});
+		const branches = root.children ?? [];
+		this.rimLabels(disc, labels ? branches.map((node) => {
+			const { a0, a1 } = spans.get(node);
+			return {
+				key: node.data.name,
+				angle: (a0 + a1) / 2,
+				text: node.data.name
+			};
+		}) : []);
+	}
+};
+export { SunburstBar };

package/dist/charts/radial/TemporalPolar.js

@@ -0,0 +1,110 @@
+import { ScaleKind } from "../../core/enums.js";
+import { Polar, TAU } from "./Polar.js";
+import { PolarBase } from "./PolarBase.js";
+import { PolarLayout } from "./radialEnums.js";
+import { scaleLinear, scaleUtc, utcFormat } from "d3";
+// src/charts/radial/TemporalPolar.ts
+var OPENING = .965;
+var MAX_HITS = 120;
+/** Polar charts of a time series: one lap of the circle from first date to last, with a gap where it would wrap. */
+var TemporalPolar = class extends PolarBase {
+	defaults() {
+		return {
+			date: "date",
+			series: "series",
+			value: "value"
+		};
+	}
+	timeline() {
+		const { data, date, series, value } = this.options;
+		const rows = Polar.rows(data);
+		const sums = /* @__PURE__ */ new Map();
+		for (const row of rows) {
+			const t = Polar.time(row[date]);
+			if (t === null) continue;
+			const name = String(row[series] ?? "Value"), v = Polar.number(row[value]);
+			const track = sums.get(name) ?? /* @__PURE__ */ new Map();
+			const seen = track.get(t) ?? null;
+			track.set(t, v === null ? seen : (seen ?? 0) + v);
+			sums.set(name, track);
+		}
+		const tracks = [...sums].map(([name, points]) => ({
+			name,
+			points: [...points].map(([t, v]) => ({
+				t,
+				value: v
+			})).sort((a, b) => a.t - b.t)
+		}));
+		const times = [...new Set(tracks.flatMap((track) => track.points.map((point) => point.t)))].sort((a, b) => a - b);
+		const first = times[0] ?? 0, last = times[times.length - 1] ?? 1;
+		return {
+			tracks,
+			times,
+			angle: scaleLinear([first, last > first ? last : first + 1], [0, TAU * OPENING]),
+			dated: rows.some((row) => typeof row[date] !== "number")
+		};
+	}
+	stamp(t, dated) {
+		return dated ? utcFormat("%b %-d")(new Date(t)) : Polar.label(t);
+	}
+	/** Rim dates with spokes, for the part of the circle between `r0` and `r1`. */
+	timeAxis(disc, { angle, dated }, r0, r1) {
+		const [from, to] = angle.domain();
+		const ticks = dated ? scaleUtc([from, to], [0, 1]).ticks(6).map(Number) : scaleLinear([from, to], [0, 1]).ticks(6);
+		this.spokes(disc, ticks.map((tick) => angle(tick)), r0, r1);
+		this.rimLabels(disc, ticks.map((tick) => ({
+			key: `${tick}`,
+			angle: angle(tick),
+			text: this.stamp(tick, dated)
+		})));
+	}
+	/** One lane per series, or a shared one. `zero` pins the value axis at zero. */
+	lanes(tracks, inner, outer, layout, zero) {
+		const values = (list) => list.flatMap((track) => track.points.flatMap((point) => point.value === null ? [] : [point.value]));
+		if (layout === PolarLayout.Overlay) {
+			const radius = Polar.scale(ScaleKind.Linear, values(tracks), [inner, outer], zero);
+			return tracks.map((track) => ({
+				track,
+				inner,
+				outer,
+				radius
+			}));
+		}
+		const band = (outer - inner) / Math.max(1, tracks.length);
+		return tracks.map((track, i) => {
+			const low = inner + i * band, high = low + band - 6;
+			return {
+				track,
+				inner: low,
+				outer: high,
+				radius: Polar.scale(ScaleKind.Linear, values([track]), [low, high], zero)
+			};
+		});
+	}
+	/** Series names at the top of each concentric lane. */
+	laneLabels(disc, lanes) {
+		const { ctx } = disc;
+		const text = ctx.marks("lane-labels", "text", lanes.length > 1 && lanes[0].inner !== lanes[1].inner ? lanes : [], (d) => d.track.name).attr("paint-order", "stroke").attr("stroke", ctx.theme.surface).attr("stroke-width", 3);
+		ctx.text(text, 10).attr("text-anchor", "end").attr("x", -4).attr("y", (d) => -d.inner - 2).text((d) => d.track.name);
+	}
+	timeHits(disc, { tracks, times, angle, dated }, r0, r1, extra) {
+		const stride = Math.ceil(times.length / MAX_HITS);
+		const kept = times.filter((_, i) => i % stride === 0);
+		const half = kept.length > 1 ? (angle(kept[1]) - angle(kept[0])) / 2 : Math.PI;
+		this.hits(disc, kept.map((t) => ({
+			key: `${t}`,
+			a0: angle(t) - half,
+			a1: angle(t) + half,
+			r0,
+			r1,
+			tip: {
+				title: this.stamp(t, dated),
+				rows: extra?.(t) ?? tracks.flatMap((track) => {
+					const value = track.points.find((point) => point.t === t)?.value;
+					return value === null || value === void 0 ? [] : [[track.name, value]];
+				})
+			}
+		})));
+	}
+};
+export { TemporalPolar };

package/dist/charts/radial/WindRoseChart.js

@@ -0,0 +1,164 @@
+import { DataShape, StackMode } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { Polar, TAU } from "./Polar.js";
+import { PolarBase, polarMeta } from "./PolarBase.js";
+import { WindBinning } from "./radialEnums.js";
+import { quantile } from "d3";
+// src/charts/radial/WindRoseChart.ts
+var COMPASS = [
+	"N",
+	"NNE",
+	"NE",
+	"ENE",
+	"E",
+	"ESE",
+	"SE",
+	"SSE",
+	"S",
+	"SSW",
+	"SW",
+	"WSW",
+	"W",
+	"WNW",
+	"NW",
+	"NNW"
+];
+/** How often the wind, or anything else with a bearing, comes from each direction, split by speed. */
+var WindRoseChart = class extends PolarBase {
+	static meta = {
+		...polarMeta,
+		id: "wind-rose",
+		name: "Wind rose",
+		shape: DataShape.Table,
+		description: "Bins bearings into compass sectors and splits each by speed, showing prevailing direction and strength.",
+		tags: [
+			"compass",
+			"direction",
+			"meteorology"
+		],
+		sample: (seed) => SampleData.points(seed, 480, 3).map((row) => ({
+			direction: +((row.x * 5 + 40) % 360).toFixed(1),
+			speed: +(row.size / 3).toFixed(1)
+		})),
+		variants: {
+			sectors: [
+				16,
+				8,
+				12
+			],
+			bands: [4, 6],
+			binning: [WindBinning.Equal, WindBinning.Quantile],
+			stack: [StackMode.Stacked, StackMode.None]
+		},
+		valid: (values) => values.stack === StackMode.Stacked || values.sectors * values.bands <= 48
+	};
+	swatches = [];
+	defaults() {
+		return {
+			direction: "direction",
+			speed: "speed",
+			unit: "m/s",
+			sectors: 16,
+			bands: 4,
+			binning: WindBinning.Equal,
+			stack: StackMode.Stacked
+		};
+	}
+	legendItems() {
+		return this.swatches;
+	}
+	readings() {
+		const { data, direction, speed } = this.options;
+		return Polar.rows(data).flatMap((row) => {
+			const d = Polar.number(row[direction]), s = Polar.number(row[speed]);
+			return d === null || s === null ? [] : [{
+				direction: (d % 360 + 360) % 360,
+				speed: Math.max(0, s)
+			}];
+		});
+	}
+	edges(speeds) {
+		const { bands, binning } = this.options;
+		const count = bands, sorted = [...speeds].sort((a, b) => a - b);
+		const peak = sorted[sorted.length - 1] ?? 1;
+		return [
+			0,
+			...Array.from({ length: count - 1 }, (_, i) => binning === WindBinning.Equal ? peak * (i + 1) / count : quantile(sorted, (i + 1) / count) ?? 0).map((edge) => +edge.toFixed(1)),
+			peak
+		];
+	}
+	drawRadial(ctx, frame) {
+		const disc = this.disc(ctx, frame);
+		const { sectors, unit, stack, bands } = this.options;
+		const readings = this.readings(), edges = this.edges(readings.map((d) => d.speed));
+		const count = sectors, step = TAU / count, share = 100 / Math.max(1, readings.length);
+		const table = Array.from({ length: count }, () => new Array(bands).fill(0));
+		for (const { direction, speed } of readings) {
+			const sector = Math.round(direction / (360 / count)) % count;
+			const band = Math.max(0, edges.findIndex((edge, i) => i > 0 && speed <= edge) - 1);
+			table[sector][band] += share;
+		}
+		const grouped = stack === StackMode.None;
+		const peak = Math.max(0, ...table.map((row) => grouped ? Math.max(...row) : row.reduce((a, b) => a + b, 0)));
+		const { top, ticks } = Polar.magnitude(peak);
+		const hole = disc.radius * .1;
+		const radius = Polar.areaRadius(hole, disc.radius, top);
+		const shade = (band) => ctx.palette.sequential(.15 + .85 * band / Math.max(1, bands - 1));
+		const name = (band) => `${edges[band]}–${edges[band + 1]} ${unit}`;
+		this.swatches = Array.from({ length: bands }, (_, band) => ({
+			key: band === bands - 1 ? name(band) : `${edges[band]}–${edges[band + 1]}`,
+			color: shade(band)
+		}));
+		this.rings(disc, ticks.map((tick) => ({
+			r: radius(tick),
+			text: `${tick}%`
+		})));
+		const spokeStep = TAU / (count > 8 ? 16 : count);
+		this.spokes(disc, Array.from({ length: Math.round(TAU / spokeStep) }, (_, i) => i * spokeStep), hole, disc.radius);
+		const wedges = table.flatMap((row, s) => {
+			let cursor = 0;
+			return row.map((value, band) => {
+				const color = shade(band), a = s * step - step / 2;
+				const base = {
+					key: `${s}/${band}`,
+					fill: color,
+					tip: {
+						title: this.bearing(s),
+						color,
+						rows: [[name(band), `${value.toFixed(1)}%`]]
+					}
+				};
+				if (grouped) {
+					const w = step * .84 / bands;
+					const a0 = a + step * .08 + band * w;
+					return {
+						...base,
+						a0,
+						a1: a0 + w,
+						r0: hole,
+						r1: radius(value)
+					};
+				}
+				const r0 = radius(cursor) + (cursor ? 1 : 0);
+				cursor += value;
+				return {
+					...base,
+					a0: a + step * .06,
+					a1: a + step * .94,
+					r0,
+					r1: radius(cursor) - (cursor ? 1 : 0)
+				};
+			});
+		});
+		this.wedges(disc, wedges, { corner: 2 });
+		this.rimLabels(disc, Array.from({ length: count }, (_, s) => s).filter((s) => s * 360 / count % 45 === 0).map((s) => ({
+			angle: s * step,
+			text: this.bearing(s)
+		})));
+	}
+	bearing(sector) {
+		const degrees = sector * 360 / this.options.sectors;
+		return degrees % 22.5 === 0 ? COMPASS[degrees / 22.5] : `${degrees}°`;
+	}
+};
+export { WindRoseChart };

package/dist/charts/radial/index.js

@@ -0,0 +1,47 @@
+import { CircularBarplotArrange, CircularHeatCell, CircularHeatOrder, ClockDial, ClockMark, ClockOrigin, CoxcombLayering, CoxcombLayout, PolarDirection, PolarLabels, PolarLayout, PolarOverlay, PolarSort, PolarSpan, RadarGrid, RadarLayout, RadarScaling, RadialBarStack, RadialBaseline, RadialBoxMark, RadialColumnMark, RadialDumbbellConnector, RadialDumbbellSort, RadialGanttLayout, RadialGanttSort, RadialHistogramBinning, RadialHistogramMark, RadialStackOffset, RadialStackOrder, RadialWhisker, SunburstBarLevels, SunburstBarSizing, TimeSpiralGrowth, TimeSpiralMark, WindBinning } from "./radialEnums.js";
+import { PolarBase } from "./PolarBase.js";
+import { CircularBarplot } from "./CircularBarplot.js";
+import { CircularHeatmap } from "./CircularHeatmap.js";
+import { ClockChart } from "./ClockChart.js";
+import { CoxcombChart } from "./CoxcombChart.js";
+import { PolarAreaChart } from "./PolarAreaChart.js";
+import { PolarScatter } from "./PolarScatter.js";
+import { RadarChart } from "./RadarChart.js";
+import { TemporalPolar } from "./TemporalPolar.js";
+import { RadialAreaChart } from "./RadialAreaChart.js";
+import { RadialBarChart } from "./RadialBarChart.js";
+import { RadialBoxPlot } from "./RadialBoxPlot.js";
+import { RadialColumnChart } from "./RadialColumnChart.js";
+import { RadialDumbbell } from "./RadialDumbbell.js";
+import { RadialGantt } from "./RadialGantt.js";
+import { RadialHistogram } from "./RadialHistogram.js";
+import { RadialLineChart } from "./RadialLineChart.js";
+import { RadialStackedArea } from "./RadialStackedArea.js";
+import { RoseChart } from "./RoseChart.js";
+import { SpiralChart } from "./SpiralChart.js";
+import { SunburstBar } from "./SunburstBar.js";
+import { WindRoseChart } from "./WindRoseChart.js";
+// src/charts/radial/index.ts
+var radialCatalog = [
+	RadarChart,
+	PolarAreaChart,
+	RoseChart,
+	RadialBarChart,
+	CircularBarplot,
+	RadialLineChart,
+	RadialAreaChart,
+	RadialStackedArea,
+	SpiralChart,
+	CoxcombChart,
+	RadialColumnChart,
+	ClockChart,
+	WindRoseChart,
+	CircularHeatmap,
+	RadialHistogram,
+	SunburstBar,
+	PolarScatter,
+	RadialDumbbell,
+	RadialBoxPlot,
+	RadialGantt
+];
+export { CircularBarplot, CircularBarplotArrange, CircularHeatCell, CircularHeatOrder, CircularHeatmap, ClockChart, ClockDial, ClockMark, ClockOrigin, CoxcombChart, CoxcombLayering, CoxcombLayout, PolarAreaChart, PolarBase, PolarDirection, PolarLabels, PolarLayout, PolarOverlay, PolarScatter, PolarSort, PolarSpan, RadarChart, RadarGrid, RadarLayout, RadarScaling, RadialAreaChart, RadialBarChart, RadialBarStack, RadialBaseline, RadialBoxMark, RadialBoxPlot, RadialColumnChart, RadialColumnMark, RadialDumbbell, RadialDumbbellConnector, RadialDumbbellSort, RadialGantt, RadialGanttLayout, RadialGanttSort, RadialHistogram, RadialHistogramBinning, RadialHistogramMark, RadialLineChart, RadialStackOffset, RadialStackOrder, RadialStackedArea, RadialWhisker, RoseChart, SpiralChart, SunburstBar, SunburstBarLevels, SunburstBarSizing, TemporalPolar, TimeSpiralGrowth, TimeSpiralMark, WindBinning, WindRoseChart, radialCatalog };