@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/radial/ClockChart.js

@@ -0,0 +1,221 @@
+import { CurveKind, DataShape } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { Polar, TAU } from "./Polar.js";
+import { PolarBase, polarMeta } from "./PolarBase.js";
+import { ClockDial, ClockMark, ClockOrigin } from "./radialEnums.js";
+import { areaRadial, scaleLinear } from "d3";
+// src/charts/radial/ClockChart.ts
+var HOURS = 24;
+var HOLE = .3;
+/** Daily rhythms: activity, demand or sleep by hour, read like a clock face. */
+var ClockChart = class extends PolarBase {
+	static meta = {
+		...polarMeta,
+		id: "clock",
+		name: "Clock chart",
+		shape: DataShape.Table,
+		description: "Maps values to the hours of a clock face, making the daily rhythm and busiest time obvious at a glance.",
+		tags: [
+			"24-hour",
+			"time of day",
+			"daily rhythm"
+		],
+		sample: (seed) => SampleData.timeSeries(seed, 72, 1).map((row, i) => {
+			const hour = i % HOURS;
+			return {
+				hour,
+				value: +(row.value * (1.1 + Math.sin((hour - 9) / HOURS * TAU))).toFixed(1)
+			};
+		}),
+		variants: {
+			mark: [
+				ClockMark.Wedges,
+				ClockMark.Area,
+				ClockMark.Heat,
+				ClockMark.Dots
+			],
+			dial: [ClockDial.Day, ClockDial.Split],
+			origin: [ClockOrigin.Midnight, ClockOrigin.Noon],
+			peak: [true, false]
+		},
+		valid: (values) => !(values.dial === ClockDial.Split && values.origin === ClockOrigin.Noon)
+	};
+	defaults() {
+		return {
+			hour: "hour",
+			value: "value",
+			mark: ClockMark.Wedges,
+			dial: ClockDial.Day,
+			origin: ClockOrigin.Midnight,
+			peak: true
+		};
+	}
+	totals() {
+		const { data, hour, value } = this.options;
+		const totals = new Array(HOURS).fill(0);
+		for (const row of Polar.rows(data)) {
+			const cell = row[hour], v = Polar.number(row[value]);
+			const h = cell instanceof Date ? cell.getUTCHours() : Polar.number(cell);
+			if (h !== null && v !== null) totals[(Math.floor(h) % HOURS + HOURS) % HOURS] += v;
+		}
+		return totals;
+	}
+	bins(radius, totals) {
+		const { dial, origin } = this.options;
+		const split = dial === ClockDial.Split, hole = radius * HOLE, middle = (hole + radius) / 2;
+		const turn = origin === ClockOrigin.Noon ? 12 : 0;
+		return totals.map((value, hour) => {
+			const pm = hour >= 12;
+			return {
+				hour,
+				value,
+				half: TAU / (split ? 24 : 48),
+				angle: split ? hour % 12 / 12 * TAU : (hour - turn + HOURS) % HOURS / HOURS * TAU,
+				inner: split && pm ? middle + 3 : hole,
+				outer: split && !pm ? middle - 3 : radius,
+				ring: split ? pm ? "PM" : "AM" : ""
+			};
+		});
+	}
+	drawRadial(ctx, frame) {
+		const disc = this.disc(ctx, frame, 26);
+		const totals = this.totals();
+		const bins = this.bins(disc.radius, totals);
+		const top = Polar.magnitude(Math.max(0, ...totals)).top;
+		const reach = (d, value = d.value) => d.inner + Math.max(0, value) / top * (d.outer - d.inner);
+		const tiers = [...new Map(bins.map((d) => [d.ring, d])).values()];
+		this.rings(disc, tiers.flatMap((d) => [{
+			r: d.inner,
+			text: `${d.ring}-in`
+		}, {
+			r: d.outer,
+			text: `${d.ring}-out`
+		}]), { labels: false });
+		this.face(disc, bins);
+		this.paintMark(disc, bins, reach, tiers, top);
+		if (this.options.peak) this.hand(disc, bins, reach);
+		const half = bins[0].half;
+		this.hits(disc, bins.map((d) => ({
+			key: `${d.hour}`,
+			a0: d.angle - half,
+			a1: d.angle + half,
+			r0: d.inner,
+			r1: d.outer,
+			tip: {
+				title: `${String(d.hour).padStart(2, "0")}:00`,
+				rows: [[this.options.value, d.value]]
+			}
+		})));
+	}
+	face(disc, bins) {
+		const { ctx, radius } = disc;
+		const split = this.options.dial === ClockDial.Split;
+		const ticks = ctx.marks("ticks", "line", bins.filter((d) => d.ring !== "PM"), (d) => d.hour).attr("stroke", ctx.theme.axis);
+		const major = (d) => d.hour % (split ? 3 : 6) === 0;
+		ctx.set(ticks, {
+			x1: (d) => Polar.point(d.angle, radius + 2)[0],
+			y1: (d) => Polar.point(d.angle, radius + 2)[1],
+			x2: (d) => Polar.point(d.angle, radius + (major(d) ? 8 : 5))[0],
+			y2: (d) => Polar.point(d.angle, radius + (major(d) ? 8 : 5))[1]
+		}, {});
+		this.rimLabels(disc, bins.filter((d) => d.ring !== "PM" && major(d)).map((d) => ({
+			angle: d.angle,
+			radius: radius + 17,
+			text: split ? String(d.hour || 12) : `${String(d.hour).padStart(2, "0")}:00`
+		})));
+		const rings = ctx.marks("ring-labels", "text", split ? [...new Map(bins.map((d) => [d.ring, d])).values()] : [], (d) => d.ring).attr("paint-order", "stroke").attr("stroke", ctx.theme.surface).attr("stroke-width", 3);
+		ctx.text(rings, 10, "muted").attr("text-anchor", "end").attr("dx", -4).attr("dy", ".35em").attr("x", 0).attr("y", (d) => -(d.inner + d.outer) / 2).text((d) => d.ring);
+	}
+	paintMark(disc, bins, reach, tiers, top) {
+		const { ctx } = disc;
+		const { mark, value } = this.options;
+		const color = ctx.palette.color(value);
+		const label = (d) => ({
+			title: `${String(d.hour).padStart(2, "0")}:00`,
+			color,
+			rows: [[value, d.value]]
+		});
+		const shade = scaleLinear([0, top], [.05, 1]);
+		this.wedges(disc, mark === ClockMark.Wedges ? bins.map((d) => ({
+			key: `${d.hour}`,
+			a0: d.angle - d.half,
+			a1: d.angle + d.half,
+			r0: d.inner,
+			r1: reach(d),
+			fill: color,
+			tip: label(d)
+		})) : mark === ClockMark.Heat ? bins.map((d) => ({
+			key: `${d.hour}`,
+			a0: d.angle - d.half,
+			a1: d.angle + d.half,
+			r0: d.inner,
+			r1: d.outer,
+			fill: ctx.palette.sequential(shade(d.value)),
+			tip: label(d)
+		})) : [], { stagger: 20 });
+		const ribbons = mark === ClockMark.Area ? tiers.map((tier) => {
+			const own = bins.filter((d) => d.ring === tier.ring).sort((a, b) => a.angle - b.angle);
+			return {
+				key: tier.ring,
+				own
+			};
+		}) : [];
+		const shape = (flat) => areaRadial().angle((d) => d.angle).innerRadius((d) => d.inner).outerRadius((d) => flat ? d.inner + .5 : reach(d)).curve(Polar.curve(CurveKind.CatmullRom, true));
+		const areas = ctx.marks("areas", "path", ribbons, (d) => d.key).attr("fill", color).attr("fill-opacity", .85).attr("fill-rule", "evenodd");
+		ctx.set(areas, { d: (d) => shape(false)(d.own) }, { d: (d) => shape(true)(d.own) });
+		const dots = ctx.marks("dots", "circle", mark === ClockMark.Dots ? bins : [], (d) => d.hour).attr("fill", color);
+		this.ringed(ctx, dots);
+		ctx.set(dots, {
+			cx: (d) => Polar.point(d.angle, reach(d))[0],
+			cy: (d) => Polar.point(d.angle, reach(d))[1],
+			r: 5
+		}, {
+			cx: (d) => Polar.point(d.angle, d.inner)[0],
+			cy: (d) => Polar.point(d.angle, d.inner)[1],
+			r: 0
+		}, 20);
+		const stems = ctx.marks("stems", "line", mark === ClockMark.Dots ? bins : [], (d) => d.hour).attr("stroke", color).attr("stroke-width", 2);
+		ctx.set(stems, {
+			x1: (d) => Polar.point(d.angle, d.inner)[0],
+			y1: (d) => Polar.point(d.angle, d.inner)[1],
+			x2: (d) => Polar.point(d.angle, reach(d))[0],
+			y2: (d) => Polar.point(d.angle, reach(d))[1]
+		}, {
+			x2: (d) => Polar.point(d.angle, d.inner)[0],
+			y2: (d) => Polar.point(d.angle, d.inner)[1]
+		}, 20);
+	}
+	hand(disc, bins, reach) {
+		const { ctx } = disc;
+		const busiest = bins.reduce((best, d) => d.value > best.value ? d : best, bins[0]);
+		const hole = disc.radius * HOLE;
+		const hand = ctx.marks("hand", "line", [busiest], () => "hand").attr("stroke", ctx.theme.ink).attr("stroke-width", 2).attr("stroke-linecap", "round");
+		const tip = Polar.point(busiest.angle, reach(busiest));
+		ctx.set(hand, {
+			x1: 0,
+			y1: 0,
+			x2: tip[0],
+			y2: tip[1]
+		}, {
+			x1: 0,
+			y1: 0,
+			x2: 0,
+			y2: 0
+		});
+		const cap = ctx.marks("hub", "circle", [busiest], () => "hub").attr("fill", ctx.theme.surface).attr("stroke", ctx.theme.axis);
+		ctx.set(cap, {
+			cx: 0,
+			cy: 0,
+			r: hole - 6
+		}, {
+			cx: 0,
+			cy: 0,
+			r: 0
+		});
+		const room = (hole - 6) * 2;
+		const lines = [...room >= 44 ? [`${String(busiest.hour).padStart(2, "0")}:00`] : [], ...room >= 56 ? ["busiest"] : []];
+		const words = ctx.marks("peak", "text", lines, (d) => d);
+		ctx.text(words, 13, "ink").attr("text-anchor", "middle").attr("x", 0).attr("dy", ".35em").attr("y", (_, i) => lines.length > 1 ? i ? 8 : -6 : 0).attr("font-size", (_, i) => i ? 10 : 13).attr("font-weight", (_, i) => i ? 400 : 600).text((d) => d);
+	}
+};
+export { ClockChart };

package/dist/charts/radial/CoxcombChart.js

@@ -0,0 +1,125 @@
+import { DataShape } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { Polar, TAU } from "./Polar.js";
+import { PolarBase, polarMeta } from "./PolarBase.js";
+import { CoxcombLayering, CoxcombLayout } from "./radialEnums.js";
+import { max } from "d3";
+// src/charts/radial/CoxcombChart.ts
+var MONTHS = [
+	"Jan",
+	"Feb",
+	"Mar",
+	"Apr",
+	"May",
+	"Jun",
+	"Jul",
+	"Aug",
+	"Sep",
+	"Oct",
+	"Nov",
+	"Dec"
+];
+/** Nightingale's coxcomb: seasonal totals by cause, with wedges layered from one origin. */
+var CoxcombChart = class extends PolarBase {
+	static meta = {
+		...polarMeta,
+		id: "coxcomb",
+		name: "Coxcomb chart",
+		shape: DataShape.Table,
+		description: "Layers series as wedges from one origin round the months, showing how a seasonal pattern shifts by cause.",
+		tags: [
+			"nightingale",
+			"seasonal",
+			"months"
+		],
+		sample: (seed) => [1, 2].flatMap((year) => {
+			const rows = SampleData.categories(seed + year, 12, 3), months = [...new Set(rows.map((row) => row.category))];
+			return rows.map((row) => ({
+				...row,
+				category: `${MONTHS[months.indexOf(row.category)]} ${24 + year}`
+			}));
+		}),
+		variants: {
+			layering: [CoxcombLayering.LargestBack, CoxcombLayering.Stacked],
+			layout: [CoxcombLayout.Twin, CoxcombLayout.Single],
+			hole: [
+				.08,
+				0,
+				.25
+			],
+			labels: [true, false]
+		},
+		/** Stacked on one disc is a `RoseChart`: the coxcomb adds layering from one origin or twin discs. */
+		valid: ({ layering, layout }) => layering === CoxcombLayering.LargestBack || layout === CoxcombLayout.Twin
+	};
+	defaults() {
+		return {
+			category: "category",
+			series: "series",
+			value: "value",
+			layering: CoxcombLayering.LargestBack,
+			layout: CoxcombLayout.Twin,
+			hole: .08,
+			labels: true
+		};
+	}
+	amount(pivot, c, s) {
+		return Math.max(0, pivot.at(c, s) ?? 0);
+	}
+	drawRadial(ctx, frame) {
+		const { category, series, value, layout, layering } = this.options;
+		const pivot = Polar.pivot(this.data, category, series, value);
+		const { categories } = pivot;
+		pivot.series.forEach((name) => ctx.palette.color(name));
+		const twin = layout === CoxcombLayout.Twin && categories.length > 1;
+		const middle = Math.ceil(categories.length / 2);
+		const parts = twin ? [categories.slice(0, middle), categories.slice(middle)] : [categories];
+		const peak = layering === CoxcombLayering.Stacked ? max(categories, (c) => pivot.series.reduce((sum, s) => sum + this.amount(pivot, c, s), 0)) : max(pivot.values);
+		const { top, ticks } = Polar.magnitude(peak ?? 1);
+		this.facets(ctx, frame, parts.length, (disc, i) => {
+			this.cycle(disc, pivot, parts[i], top, ticks);
+			if (twin) this.facetTitle(disc, `${parts[i][0]} – ${parts[i][parts[i].length - 1]}`);
+		});
+	}
+	cycle(disc, pivot, months, top, ticks) {
+		const { ctx } = disc;
+		const { layering, hole, labels } = this.options;
+		const inner = disc.radius * hole, step = TAU / Math.max(1, months.length);
+		const radius = Polar.areaRadius(inner, disc.radius, top);
+		this.rings(disc, ticks.map((tick) => ({
+			r: radius(tick),
+			text: Polar.label(tick)
+		})));
+		const layered = layering === CoxcombLayering.LargestBack;
+		const wedges = months.flatMap((c, i) => {
+			const names = layered ? [...pivot.series].sort((a, b) => this.amount(pivot, c, b) - this.amount(pivot, c, a)) : pivot.series;
+			let cursor = 0;
+			return names.map((s) => {
+				const v = this.amount(pivot, c, s), color = ctx.palette.color(s);
+				const r0 = layered ? inner : radius(cursor) + (cursor ? 1 : 0);
+				cursor += v;
+				return {
+					key: `${c}/${s}`,
+					a0: i * step,
+					a1: (i + 1) * step,
+					r0,
+					r1: layered ? radius(v) : radius(cursor) - 1,
+					fill: color,
+					ring: layered,
+					tip: {
+						title: c,
+						color,
+						rows: [[s, pivot.at(c, s) ?? 0]]
+					}
+				};
+			});
+		});
+		this.wedges(disc, wedges);
+		this.rimLabels(disc, labels ? months.map((c, i) => ({
+			key: c,
+			angle: (i + .5) * step,
+			text: this.options.layout === CoxcombLayout.Twin ? c.split(" ")[0] : c
+		})) : []);
+	}
+};
+export { CoxcombChart };

package/dist/charts/radial/Polar.js

@@ -0,0 +1,125 @@
+import { CurveKind, ScaleKind } from "../../core/enums.js";
+import { Scales } from "../../core/Scales.js";
+import { PolarSort, PolarSpan } from "./radialEnums.js";
+import { curveBasis, curveBasisClosed, curveCardinal, curveCardinalClosed, curveCatmullRom, curveCatmullRomClosed, curveLinear, curveLinearClosed, max, min, nice, ticks } from "d3";
+// src/charts/radial/Polar.ts
+var TAU = Math.PI * 2;
+var CHAR = 6.2;
+var OPEN = {
+	[CurveKind.Linear]: curveLinear,
+	[CurveKind.Cardinal]: curveCardinal,
+	[CurveKind.CatmullRom]: curveCatmullRom,
+	[CurveKind.Basis]: curveBasis
+};
+var CLOSED = {
+	[CurveKind.Linear]: curveLinearClosed,
+	[CurveKind.Cardinal]: curveCardinalClosed,
+	[CurveKind.CatmullRom]: curveCatmullRomClosed,
+	[CurveKind.Basis]: curveBasisClosed
+};
+/** Pure polar maths and row reshaping shared by every radial chart. Angles are radians, clockwise from 12 o'clock. */
+var Polar = class Polar {
+	static point(angle, radius) {
+		return [Math.sin(angle) * radius, -Math.cos(angle) * radius];
+	}
+	static degrees(angle) {
+		return angle * 180 / Math.PI;
+	}
+	static number(cell) {
+		if (cell === null || cell === void 0 || cell === "") return null;
+		const value = +cell;
+		return Number.isFinite(value) ? value : null;
+	}
+	static time(cell) {
+		if (cell instanceof Date) return Polar.number(+cell);
+		if (typeof cell === "string") {
+			const parsed = Date.parse(cell);
+			return Number.isNaN(parsed) ? Polar.number(cell) : parsed;
+		}
+		return Polar.number(cell);
+	}
+	static rows(data) {
+		return Array.isArray(data) ? data : [];
+	}
+	/** Long rows to a category × series table. Duplicate keys sum; rows with no category are skipped. */
+	static pivot(data, category, series, value) {
+		const cells = /* @__PURE__ */ new Map(), totals = /* @__PURE__ */ new Map();
+		const categories = /* @__PURE__ */ new Set(), names = /* @__PURE__ */ new Set();
+		for (const row of Polar.rows(data)) {
+			if (row[category] === null || row[category] === void 0) continue;
+			const c = String(row[category]), s = String(row[series] ?? "Value"), v = Polar.number(row[value]);
+			categories.add(c);
+			names.add(s);
+			if (v === null) continue;
+			cells.set(`${c}\u0000${s}`, (cells.get(`${c}\u0000${s}`) ?? 0) + v);
+			totals.set(c, (totals.get(c) ?? 0) + v);
+		}
+		return {
+			categories: [...categories],
+			series: [...names],
+			values: [...cells.values()],
+			at: (c, s) => cells.get(`${c}\u0000${s}`) ?? null,
+			total: (c) => totals.get(c) ?? 0
+		};
+	}
+	static sorted(items, by, sort) {
+		if (sort === PolarSort.Data) return [...items];
+		const sign = sort === PolarSort.Descending ? -1 : 1;
+		return [...items].sort((a, b) => sign * (by(a) - by(b)));
+	}
+	static span(kind) {
+		if (kind === PolarSpan.Gauge) return [-TAU * .375, TAU * .375];
+		if (kind === PolarSpan.Half) return [-Math.PI / 2, Math.PI / 2];
+		return [0, TAU];
+	}
+	static curve(kind, closed = false) {
+		return (closed ? CLOSED : OPEN)[kind] ?? curveLinear;
+	}
+	/** Text cut to the room available in px, or empty when not even three characters fit. */
+	static fit(text, room, char = CHAR) {
+		const fits = Math.floor(room / char);
+		if (text.length <= fits) return text;
+		return fits >= 4 ? `${text.slice(0, fits - 1)}…` : "";
+	}
+	/** Maps a magnitude to a radius so that the annulus area, not the radius, is proportional to it. */
+	static areaRadius(hole, outer, top) {
+		return (value) => Math.sqrt(hole * hole + Math.max(0, value) / (top || 1) * (outer * outer - hole * hole));
+	}
+	/** Radial scale over `values`, zero-based unless `zero` is false. Log scales clamp non-positive values to the floor. */
+	static scale(kind, values, range, zero = true) {
+		const hi = max(values) ?? 1, lo = min(values) ?? 0;
+		if (kind === ScaleKind.Log) {
+			const floor = min(values.filter((value) => value > 0)) ?? 1;
+			return Scales.continuous(kind).domain([floor, hi > floor ? hi : floor * 10]).range(range).clamp(true).nice();
+		}
+		const start = zero ? Math.min(0, lo) : lo;
+		return Scales.continuous(kind).domain([start, hi > start ? hi : start + 1]).range(range).nice();
+	}
+	/** About `count` ticks, thinned so log scales do not crowd the grid. */
+	static ticks(scale, count = 3) {
+		const all = scale.ticks(count), stride = Math.ceil(all.length / (count + 2));
+		return all.filter((_, i) => i % stride === 0);
+	}
+	/** Nice top and positive ticks for a zero-based magnitude. */
+	static magnitude(top, count = 3) {
+		const [, end] = nice(0, top || 1, count);
+		return {
+			top: end,
+			ticks: ticks(0, end, count).filter((tick) => tick > 0)
+		};
+	}
+	static circle(r) {
+		return `M0,${-r}A${r},${r} 0 1 1 0,${r}A${r},${r} 0 1 1 0,${-r}Z`;
+	}
+	static polygon(r, angles) {
+		return `${angles.map((angle, i) => `${i ? "L" : "M"}${Polar.point(angle, r).join(",")}`).join("")}Z`;
+	}
+	static arc(r, a0, a1) {
+		const [x0, y0] = Polar.point(a0, r), [x1, y1] = Polar.point(a1, r);
+		return `M${x0},${y0}A${r},${r} 0 ${a1 - a0 > Math.PI ? 1 : 0} 1 ${x1},${y1}`;
+	}
+	static label(value) {
+		return Math.abs(value) >= 1e4 ? Scales.format(value, Math.abs(value)) : value.toLocaleString("en", { maximumFractionDigits: 2 });
+	}
+};
+export { Polar, TAU };

package/dist/charts/radial/PolarAreaChart.js

@@ -0,0 +1,90 @@
+import { DataShape } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { Polar } from "./Polar.js";
+import { PolarBase, polarMeta } from "./PolarBase.js";
+import { PolarLabels, PolarSort, PolarSpan } from "./radialEnums.js";
+import { max } from "d3";
+// src/charts/radial/PolarAreaChart.ts
+/** Show one measure over a few categories with equal-angle slices whose area carries the value. */
+var PolarAreaChart = class extends PolarBase {
+	static meta = {
+		...polarMeta,
+		id: "polar-area",
+		name: "Polar area chart",
+		shape: DataShape.Table,
+		description: "Gives every category an equal angle and scales slice area to its value, for compact cyclic comparison.",
+		tags: ["polar", "pie alternative"],
+		sample: (seed) => SampleData.categories(seed, 8, 1),
+		variants: {
+			sort: [
+				PolarSort.Data,
+				PolarSort.Descending,
+				PolarSort.Ascending
+			],
+			hole: [
+				0,
+				.25,
+				.5
+			],
+			span: [
+				PolarSpan.Full,
+				PolarSpan.Gauge,
+				PolarSpan.Half
+			],
+			labels: [
+				PolarLabels.Rim,
+				PolarLabels.Tip,
+				PolarLabels.None
+			]
+		}
+	};
+	defaults() {
+		return {
+			category: "category",
+			value: "value",
+			sort: PolarSort.Data,
+			hole: 0,
+			span: PolarSpan.Full,
+			labels: PolarLabels.Rim
+		};
+	}
+	drawRadial(ctx, frame) {
+		const { category, value, sort, hole, span, labels } = this.options;
+		const disc = this.dial(ctx, frame, span);
+		const pivot = Polar.pivot(this.data, category, category, value);
+		pivot.categories.forEach((name) => disc.ctx.palette.color(name));
+		const slices = Polar.sorted(pivot.categories.map((name) => ({
+			name,
+			value: Math.max(0, pivot.total(name)),
+			raw: pivot.total(name)
+		})), (d) => d.value, sort);
+		const [start, end] = Polar.span(span), step = (end - start) / Math.max(1, slices.length);
+		const inner = disc.radius * hole;
+		const { top, ticks } = Polar.magnitude(max(slices, (d) => d.value) ?? 1);
+		const radius = Polar.areaRadius(inner, disc.radius, top);
+		this.rings(disc, ticks.map((tick) => ({
+			r: radius(tick),
+			text: Polar.label(tick)
+		})), span === PolarSpan.Full ? {} : { sweep: [start, end] });
+		this.wedges(disc, slices.map((d, i) => ({
+			key: d.name,
+			a0: start + i * step,
+			a1: start + (i + 1) * step,
+			r0: inner,
+			r1: radius(d.value),
+			fill: disc.ctx.palette.color(d.name),
+			tip: {
+				title: d.name,
+				color: disc.ctx.palette.color(d.name),
+				rows: [[value, d.raw]]
+			}
+		})), { stagger: 30 });
+		this.rimLabels(disc, labels === PolarLabels.None ? [] : slices.map((d, i) => ({
+			key: d.name,
+			angle: start + (i + .5) * step,
+			text: d.name,
+			radius: labels === PolarLabels.Tip ? radius(d.value) + 10 : void 0
+		})));
+	}
+};
+export { PolarAreaChart };