@mstone6969/graph 0.1.0 → 0.2.0

package/dist/charts/flow/StreamFlow.js

@@ -1,174 +0,0 @@
-import { ChartFamily, CurveKind, DataShape, Dimension, Orientation } from "../../core/enums.js";
-import { Scales } from "../../core/Scales.js";
-import { SampleData } from "../../data/SampleData.js";
-import { FlowChart } from "./FlowChart.js";
-import { FlowTable } from "./FlowTable.js";
-import { area, range, scaleLinear, scalePoint, scaleTime, stack, stackOffsetExpand, stackOffsetNone, stackOffsetSilhouette, stackOffsetWiggle, stackOrderAppearance, stackOrderAscending, stackOrderDescending, stackOrderInsideOut, stackOrderNone } from "d3";
-// src/charts/flow/StreamFlow.ts
-var StreamOffset = /* @__PURE__ */ function(StreamOffset) {
-	StreamOffset["Wiggle"] = "wiggle";
-	StreamOffset["Silhouette"] = "silhouette";
-	StreamOffset["Expand"] = "expand";
-	StreamOffset["Baseline"] = "baseline";
-	return StreamOffset;
-}({});
-var StreamOrder = /* @__PURE__ */ function(StreamOrder) {
-	StreamOrder["InsideOut"] = "inside-out";
-	StreamOrder["Appearance"] = "appearance";
-	StreamOrder["Ascending"] = "ascending";
-	StreamOrder["Descending"] = "descending";
-	StreamOrder["Input"] = "input";
-	return StreamOrder;
-}({});
-var OFFSET = {
-	["wiggle"]: stackOffsetWiggle,
-	["silhouette"]: stackOffsetSilhouette,
-	["expand"]: stackOffsetExpand,
-	["baseline"]: stackOffsetNone
-};
-var ORDER = {
-	["inside-out"]: stackOrderInsideOut,
-	["appearance"]: stackOrderAppearance,
-	["ascending"]: stackOrderAscending,
-	["descending"]: stackOrderDescending,
-	["input"]: stackOrderNone
-};
-/** Watch the composition of a total drift over time, when the shape of the whole matters more than exact values. Negative amounts count as zero. */
-var StreamFlow = class extends FlowChart {
-	static meta = {
-		id: "stream-flow",
-		name: "Stream flow",
-		family: ChartFamily.Flow,
-		dimension: Dimension.Two,
-		shape: DataShape.Table,
-		description: "Stacks series around a flowing baseline to show how a total and its parts shift over time.",
-		tags: [
-			"streamgraph",
-			"theme river",
-			"stacked area"
-		],
-		sample: (seed) => SampleData.timeSeries(seed, 36, 6).map((row, i) => {
-			const peak = 5 + Math.floor(i / 36) * 11 % 31, day = i % 36;
-			return {
-				...row,
-				value: +(+row.value * (.12 + 1.4 * Math.exp(-(((day - peak) / 8) ** 2)))).toFixed(2)
-			};
-		}),
-		variants: {
-			offset: [
-				"wiggle",
-				"silhouette",
-				"expand",
-				"baseline"
-			],
-			order: [
-				"inside-out",
-				"appearance",
-				"ascending",
-				"descending",
-				"input"
-			],
-			curve: [
-				CurveKind.Basis,
-				CurveKind.Monotone,
-				CurveKind.CatmullRom,
-				CurveKind.Linear
-			],
-			orientation: [Orientation.Horizontal, Orientation.Vertical]
-		}
-	};
-	defaults() {
-		return {
-			x: "date",
-			series: "series",
-			y: "value",
-			offset: "wiggle",
-			order: "inside-out",
-			curve: CurveKind.Basis,
-			orientation: Orientation.Horizontal
-		};
-	}
-	plotMargin() {
-		return this.options.orientation === Orientation.Vertical ? {
-			top: 8,
-			right: 8,
-			bottom: 8,
-			left: 58
-		} : {
-			top: 8,
-			right: 16,
-			bottom: 26,
-			left: 16
-		};
-	}
-	draw(ctx) {
-		const { data, x, series, y, offset, order, curve, orientation } = this.options;
-		const vertical = orientation === Orientation.Vertical;
-		const table = FlowTable.pivot(data, x, series, y);
-		const rows = table.columns.map((_, c) => ({
-			c,
-			...Object.fromEntries(table.series.map((name) => [name, Math.max(0, table.at(c, name))]))
-		}));
-		const layers = stack().keys(table.series).offset(OFFSET[offset]).order(ORDER[order])(rows);
-		const [length, breadth] = vertical ? [ctx.plot.height, ctx.plot.width] : [ctx.plot.width, ctx.plot.height];
-		const low = Math.min(0, ...layers.flat().map((d) => d[0])), high = Math.max(1, ...layers.flat().map((d) => d[1]));
-		const across = scaleLinear([low, high], [breadth, 0]);
-		const first = table.columns[0];
-		const along = first instanceof Date ? (c) => scaleTime([first, table.columns[table.columns.length - 1]], [0, length])(table.columns[c]) : typeof first === "number" ? (c) => scaleLinear([first, table.columns[table.columns.length - 1]], [0, length])(table.columns[c]) : (c) => scalePoint(range(table.columns.length).map(String), [0, length])(String(c)) ?? 0;
-		const color = (name) => ctx.palette.color(name);
-		for (const name of table.series) color(name);
-		const flat = area();
-		const shape = vertical ? flat.curve(Scales.curve(curve)).y((d) => along(d.data.c)).x0((d) => across(d[0])).x1((d) => across(d[1])) : flat.curve(Scales.curve(curve)).x((d) => along(d.data.c)).y0((d) => across(d[0])).y1((d) => across(d[1]));
-		const zero = (layer) => shape(layer.map((d) => Object.assign([d[0], d[0]], { data: d.data }))) ?? "";
-		const paths = ctx.marks("layers", "path", layers, (d) => d.key).attr("fill", (d) => color(d.key));
-		ctx.set(paths, { d: (d) => shape(d) ?? "" }, { d: zero }, 30);
-		ctx.hover(paths, (d) => ({
-			title: d.key,
-			color: color(d.key),
-			rows: [["Latest", +table.at(table.columns.length - 1, d.key).toFixed(2)]]
-		}));
-		const count = Math.min(Math.floor(length / (vertical ? 40 : 90)) + 1, table.columns.length);
-		const picks = count > 1 ? range(count).map((i) => Math.round(i * (table.columns.length - 1) / (count - 1))) : table.columns.length ? [0] : [];
-		this.ticks(ctx, "dates", picks.map((c, i) => vertical ? {
-			key: `t${c}`,
-			x: -6,
-			y: along(c),
-			text: table.labels[c],
-			anchor: "end"
-		} : {
-			key: `t${c}`,
-			x: along(c),
-			y: 0,
-			text: table.labels[c],
-			anchor: i === 0 ? "start" : i === picks.length - 1 ? "end" : "middle"
-		}), vertical ? "left" : "bottom");
-		this.labels(ctx, "names", layers.flatMap((layer) => {
-			const best = layer.reduce((top, d, c) => {
-				return !(c < 2 || c > layer.length - 3) && Math.abs(across(d[1]) - across(d[0])) > Math.abs(across(layer[top][1]) - across(layer[top][0])) ? c : top;
-			}, Math.min(2, Math.max(0, layer.length - 1)));
-			const d = layer[best];
-			if (!d) return [];
-			const thick = Math.abs(across(d[1]) - across(d[0])), middle = (across(d[0]) + across(d[1])) / 2;
-			const fill = ctx.palette.inkOn(color(layer.key));
-			if (thick < 15) return [];
-			return [vertical ? {
-				key: layer.key,
-				x: middle,
-				y: along(best),
-				text: layer.key,
-				anchor: "middle",
-				fill,
-				weight: 600
-			} : {
-				key: layer.key,
-				x: along(best),
-				y: middle,
-				text: layer.key,
-				anchor: "middle",
-				fill,
-				weight: 600
-			}];
-		}));
-	}
-};
-export { StreamFlow, StreamOffset, StreamOrder };

package/dist/charts/geomaps/ThiessenMap.js

@@ -1,106 +0,0 @@
-import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
-import { GeoClasses } from "./GeoClasses.js";
-import { GeoLegend } from "./GeoLegend.js";
-import { GeoProjectionKind } from "./GeoProjection.js";
-import { GeoSamples } from "./GeoSamples.js";
-import { PointMap } from "./PointMap.js";
-import { Delaunay, extent, scaleLinear } from "d3";
-// src/charts/geomaps/ThiessenMap.ts
-var GeoTessellation = /* @__PURE__ */ function(GeoTessellation) {
-	GeoTessellation["Voronoi"] = "voronoi";
-	GeoTessellation["Delaunay"] = "delaunay";
-	GeoTessellation["Both"] = "both";
-	return GeoTessellation;
-}({});
-/** Thiessen polygons: every location belongs to its nearest site, for service areas and station catchments. */
-var ThiessenMap = class extends PointMap {
-	static meta = {
-		id: "thiessen-map",
-		name: "Thiessen map",
-		family: ChartFamily.Geospatial,
-		dimension: Dimension.Two,
-		shape: DataShape.Geo,
-		description: "Divides the map into nearest-site Voronoi cells, or its Delaunay mesh, for catchments and proximity.",
-		tags: [
-			"map",
-			"voronoi",
-			"delaunay",
-			"proximity",
-			"catchment"
-		],
-		sample: (seed) => GeoSamples.scatter(seed, 70),
-		variants: {
-			tessellation: [
-				"voronoi",
-				"delaunay",
-				"both"
-			],
-			stations: [true, false],
-			coast: [true, false],
-			projection: [
-				GeoProjectionKind.NaturalEarth,
-				GeoProjectionKind.EqualEarth,
-				GeoProjectionKind.Mollweide,
-				GeoProjectionKind.Orthographic
-			]
-		},
-		valid: (values) => values.tessellation !== "delaunay" || values.coast === true
-	};
-	defaults() {
-		return {
-			...super.defaults(),
-			tessellation: "voronoi",
-			stations: true,
-			coast: true,
-			graticule: false
-		};
-	}
-	keyHeight() {
-		return GeoLegend.height;
-	}
-	drawKey(ctx, frame) {
-		const classes = new GeoClasses(this.sites(frame).map((site) => site.value));
-		GeoLegend.classes(ctx, frame, classes, (value) => ctx.palette.sequential(.05 + .8 * classes.tone(value)));
-	}
-	drawMap(ctx, frame) {
-		const { tessellation, stations, coast, value } = this.options, { theme, palette } = ctx;
-		const sites = this.sites(frame);
-		const seen = /* @__PURE__ */ new Set();
-		const unique = sites.filter((d) => {
-			const key = `${d.x.toFixed(2)},${d.y.toFixed(2)}`;
-			return seen.has(key) ? false : !!seen.add(key);
-		});
-		const delaunay = Delaunay.from(unique, (d) => d.x, (d) => d.y);
-		const voronoi = delaunay.voronoi([
-			0,
-			0,
-			frame.width,
-			frame.height
-		]);
-		const layer = ctx.group("cells-layer").attr("clip-path", this.clip(ctx, frame.path({ type: "Sphere" }) ?? ""));
-		const [low = 0, high = 1] = extent(unique, (d) => d.value);
-		const tone = scaleLinear([low, high > low ? high : low + 1], [.05, .85]);
-		const cellsOn = tessellation !== "delaunay";
-		const cells = ctx.marks("cells", "path", cellsOn ? unique : [], (d) => d.key, layer).attr("fill", (d) => palette.sequential(tone(d.value))).attr("stroke", theme.surface).attr("stroke-width", 1);
-		ctx.set(cells, {
-			d: (_, i) => voronoi.renderCell(i),
-			"fill-opacity": 1
-		}, {
-			d: (_, i) => voronoi.renderCell(i),
-			"fill-opacity": 0
-		});
-		ctx.hover(cells, (d) => ({
-			title: d.name,
-			rows: [[value, d.value]]
-		}));
-		const mesh = tessellation === "voronoi" || unique.length < 3 ? [] : [delaunay.render()];
-		ctx.marks("mesh", "path", mesh, void 0, layer).attr("d", (d) => d).attr("fill", "none").attr("stroke", tessellation === "both" ? theme.surface : theme.inkMuted).attr("stroke-width", 1);
-		ctx.marks("coast", "path", coast || tessellation === "delaunay" ? [this.land] : []).attr("d", (d) => frame.path(d) ?? "").attr("fill", tessellation === "delaunay" ? theme.grid : "none").attr("stroke", theme.inkSecondary).attr("stroke-width", this.hairline(ctx)).attr("pointer-events", "none").lower();
-		const dots = ctx.marks("stations", "circle", stations ? unique : [], (d) => d.key).attr("cx", (d) => d.x).attr("cy", (d) => d.y).attr("r", 2.5).attr("fill", theme.ink).attr("stroke", theme.surface).attr("stroke-width", 1);
-		ctx.hover(dots, (d) => ({
-			title: d.name,
-			rows: [[value, d.value]]
-		}));
-	}
-};
-export { GeoTessellation, ThiessenMap };

package/dist/charts/hierarchy/ConeTree3D.js

@@ -1,135 +0,0 @@
-import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
-import { Hierarchy3DChart } from "./Hierarchy3DChart.js";
-import { BalloonAngles, ConeAxis, HierarchySort } from "./hierarchyEnums.js";
-import { TreeSamples } from "./TreeSamples.js";
-import { max, sum } from "d3";
-import { BufferGeometry, ConeGeometry, DoubleSide, Float32BufferAttribute, Group, InstancedMesh, LineBasicMaterial, LineSegments, Mesh, MeshStandardMaterial, Object3D, SphereGeometry } from "three";
-// src/charts/hierarchy/ConeTree3D.ts
-var LEAF = .05;
-var EXTENT = 1.75;
-var WIDTH = 1.3;
-/** Robertson's cone tree: each family hangs on a cone, so a big tree stays visible as it turns. */
-var ConeTree3D = class extends Hierarchy3DChart {
-	static meta = {
-		id: "cone-tree-3d",
-		name: "3D cone tree",
-		family: ChartFamily.Hierarchy,
-		dimension: Dimension.Three,
-		shape: DataShape.Hierarchy,
-		description: "Hangs each family of children on a cone below its parent, keeping large trees visible as the view turns.",
-		tags: [
-			"robertson",
-			"three dimensional tree",
-			"cam tree"
-		],
-		sample: (seed) => TreeSamples.broad(seed, 3, 4),
-		variants: {
-			axis: Object.values(ConeAxis),
-			angles: Object.values(BalloonAngles),
-			cones: [true, false],
-			sort: [HierarchySort.ValueDescending, HierarchySort.ValueAscending]
-		}
-	};
-	defaults() {
-		return {
-			...super.defaults(),
-			axis: ConeAxis.Vertical,
-			angles: BalloonAngles.Weighted,
-			cones: true,
-			autoRotate: true
-		};
-	}
-	layout(root) {
-		const spots = /* @__PURE__ */ new Map();
-		const weighted = this.options.angles === BalloonAngles.Weighted;
-		root.eachAfter((node) => {
-			const reaches = (node.children ?? []).map((kid) => spots.get(kid).reach);
-			const ring = reaches.length ? Math.max(sum(reaches) / Math.PI, reaches.length > 1 ? max(reaches) : 0) : 0;
-			spots.set(node, {
-				reach: ring + (max(reaches) ?? LEAF),
-				ring,
-				x: 0,
-				y: 0,
-				z: 0
-			});
-		});
-		const rung = EXTENT / Math.max(1, root.height);
-		root.eachBefore((node) => {
-			const spot = spots.get(node);
-			const kids = node.children ?? [];
-			const weights = kids.map((kid) => weighted ? spots.get(kid).reach : 1);
-			const total = sum(weights) || 1;
-			let angle = 0;
-			kids.forEach((kid, i) => {
-				const share = weights[i] / total * 2 * Math.PI, heading = angle + share / 2;
-				angle += share;
-				const child = spots.get(kid);
-				child.x = spot.x + spot.ring * Math.cos(heading);
-				child.z = spot.z + spot.ring * Math.sin(heading);
-				child.y = spot.y - rung;
-			});
-		});
-		const widest = max([...spots.values()], (spot) => Math.hypot(spot.x, spot.z)) || 1;
-		for (const spot of spots.values()) {
-			spot.x *= WIDTH / widest;
-			spot.z *= WIDTH / widest;
-			spot.ring *= WIDTH / widest;
-		}
-		return spots;
-	}
-	buildTree(ctx) {
-		const { axis, cones } = this.options;
-		const root = this.tree();
-		const spots = this.layout(root);
-		const nodes = root.descendants();
-		const stage = new Group();
-		stage.position.y = EXTENT / 2 - .05;
-		if (axis === ConeAxis.Horizontal) {
-			stage.rotation.z = Math.PI / 2;
-			stage.position.set(-1.75 / 2, -.05, 0);
-		}
-		ctx.root.add(stage);
-		const ball = new InstancedMesh(new SphereGeometry(1, 16, 12), new MeshStandardMaterial({ roughness: .4 }), nodes.length);
-		ball.castShadow = true;
-		const dummy = new Object3D();
-		nodes.forEach((node, i) => {
-			const spot = spots.get(node);
-			dummy.position.set(spot.x, spot.y, spot.z);
-			dummy.scale.setScalar(node.children ? .05 : .036);
-			dummy.updateMatrix();
-			ball.setMatrixAt(i, dummy.matrix);
-			ball.setColorAt(i, ctx.color(node.depth ? this.style.branch(node) : ctx.theme.inkMuted));
-		});
-		stage.add(ball);
-		ctx.pick(ball, (i) => this.style.tooltip(nodes[i]));
-		const points = nodes.filter((node) => node.parent).flatMap((node) => {
-			const a = spots.get(node.parent), b = spots.get(node);
-			return [
-				a.x,
-				a.y,
-				a.z,
-				b.x,
-				b.y,
-				b.z
-			];
-		});
-		stage.add(new LineSegments(new BufferGeometry().setAttribute("position", new Float32BufferAttribute(points, 3)), new LineBasicMaterial({ color: ctx.theme.axis })));
-		for (const node of cones ? nodes.filter((item) => item.children) : []) {
-			const spot = spots.get(node);
-			const rung = spot.y - spots.get(node.children[0]).y;
-			const cone = new Mesh(new ConeGeometry(Math.max(.01, spot.ring), rung, 40, 1, true), new MeshStandardMaterial({
-				color: node.depth ? this.style.branch(node) : ctx.theme.inkMuted,
-				transparent: true,
-				opacity: .14,
-				side: DoubleSide,
-				depthWrite: false
-			}));
-			cone.position.set(spot.x, spot.y - rung / 2, spot.z);
-			stage.add(cone);
-		}
-		ctx.reveal((progress) => {
-			stage.scale.setScalar(Math.max(.001, .7 + .3 * progress));
-		});
-	}
-};
-export { ConeTree3D };

package/dist/charts/hierarchy/Hierarchy3DChart.js

@@ -1,27 +0,0 @@
-import { Chart3D } from "../../core/Chart3D.js";
-import { HierarchyColor } from "./hierarchyEnums.js";
-import { TreeModel, treeFieldDefaults } from "./TreeModel.js";
-import { TreeStyle } from "./TreeStyle.js";
-// src/charts/hierarchy/Hierarchy3DChart.ts
-/** Base of every 3D hierarchy chart: the same data handling and colour rules as the 2D family. */
-var Hierarchy3DChart = class extends Chart3D {
-	style;
-	defaults() {
-		return {
-			...treeFieldDefaults,
-			color: HierarchyColor.Branch
-		};
-	}
-	build(ctx) {
-		if (!new TreeModel(this.options.data, this.options).empty) this.buildTree(ctx);
-	}
-	tree(limit) {
-		const root = new TreeModel(this.options.data, this.options).root({ limit });
-		this.style = new TreeStyle(this.palette, this.theme, this.options.color, root, this.options.valueFormat);
-		return root;
-	}
-	table() {
-		return new TreeModel(this.options.data, this.options).table();
-	}
-};
-export { Hierarchy3DChart };

package/dist/charts/hierarchy/SpherePack3D.js

@@ -1,81 +0,0 @@
-import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
-import { Hierarchy3DChart } from "./Hierarchy3DChart.js";
-import { HierarchyMeasure, SpherePackShell, SpherePackStack } from "./hierarchyEnums.js";
-import { TreeSamples } from "./TreeSamples.js";
-import { pack } from "d3";
-import { CylinderGeometry, InstancedMesh, Mesh, MeshStandardMaterial, Object3D, PlaneGeometry, SphereGeometry } from "three";
-// src/charts/hierarchy/SpherePack3D.ts
-var FLOOR = -.7;
-var RISE = .14;
-/** Circle packing as balls in glass domes: each ball's footprint keeps the 2D area encoding, with levels on height. */
-var SpherePack3D = class extends Hierarchy3DChart {
-	static meta = {
-		id: "sphere-pack-3d",
-		name: "3D sphere packing",
-		family: ChartFamily.Hierarchy,
-		dimension: Dimension.Three,
-		shape: DataShape.Hierarchy,
-		description: "Places leaves as spheres inside translucent shells or on discs for each parent, lifting levels on height.",
-		tags: [
-			"bubble",
-			"nested spheres",
-			"circle packing"
-		],
-		sample: (seed) => TreeSamples.broad(seed, 3, 3),
-		variants: {
-			stack: Object.values(SpherePackStack),
-			shell: Object.values(SpherePackShell),
-			measure: [HierarchyMeasure.Value, HierarchyMeasure.LeafCount]
-		}
-	};
-	defaults() {
-		return {
-			...super.defaults(),
-			stack: SpherePackStack.Terraced,
-			shell: SpherePackShell.Dome
-		};
-	}
-	buildTree(ctx) {
-		const { stack, shell } = this.options;
-		const root = pack().size([2.1, 2.1]).padding(.02)(this.tree());
-		const leaves = root.leaves();
-		const parents = root.descendants().filter((node) => node.depth > 0 && node.children);
-		const lift = (node) => stack === SpherePackStack.Terraced ? (root.height - node.height - 1) * RISE : 0;
-		const x = (node) => node.x - 1.05, z = (node) => node.y - 1.05;
-		const floor = new Mesh(new PlaneGeometry(2.3, 2.3), new MeshStandardMaterial({ color: ctx.theme.grid }));
-		floor.rotation.x = -Math.PI / 2;
-		floor.position.y = -.701;
-		floor.receiveShadow = true;
-		ctx.root.add(floor);
-		for (const node of shell === SpherePackShell.None ? [] : parents) {
-			const color = this.style.tint(this.style.branch(node), .3);
-			const geometry = shell === SpherePackShell.Dome ? new SphereGeometry(node.r, 32, 16, 0, Math.PI * 2, 0, Math.PI / 2) : new CylinderGeometry(node.r, node.r, .02, 48);
-			const mesh = new Mesh(geometry, new MeshStandardMaterial({
-				color,
-				transparent: true,
-				opacity: shell === SpherePackShell.Dome ? .16 : .5,
-				depthWrite: false
-			}));
-			mesh.position.set(x(node), FLOOR + lift(node), z(node));
-			ctx.root.add(mesh);
-			ctx.pick(mesh, () => this.style.tooltip(node));
-		}
-		const balls = new InstancedMesh(new SphereGeometry(1, 24, 16), new MeshStandardMaterial({ roughness: .35 }), leaves.length);
-		balls.castShadow = true;
-		const dummy = new Object3D();
-		leaves.forEach((leaf, i) => balls.setColorAt(i, ctx.color(this.style.fill(leaf))));
-		ctx.reveal((progress) => {
-			leaves.forEach((leaf, i) => {
-				const r = Math.max(.001, leaf.r * progress);
-				dummy.position.set(x(leaf), FLOOR + lift(leaf) + r, z(leaf));
-				dummy.scale.setScalar(r);
-				dummy.updateMatrix();
-				balls.setMatrixAt(i, dummy.matrix);
-			});
-			balls.instanceMatrix.needsUpdate = true;
-		});
-		ctx.root.add(balls);
-		ctx.pick(balls, (i) => this.style.tooltip(leaves[i]));
-	}
-};
-export { SpherePack3D };

package/dist/charts/hierarchy/SunburstTower3D.js

@@ -1,93 +0,0 @@
-import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
-import { Hierarchy3DChart } from "./Hierarchy3DChart.js";
-import { HierarchySort, PolarSweep, TowerProfile } from "./hierarchyEnums.js";
-import { TreeSamples } from "./TreeSamples.js";
-import { max, partition } from "d3";
-import { ExtrudeGeometry, Mesh, MeshStandardMaterial, Shape } from "three";
-// src/charts/hierarchy/SunburstTower3D.ts
-var FLOOR = -.65;
-var RADIUS = 1.1;
-var GAP = .012;
-/** Sunburst with height: each ring is a solid segment, for presentations where the level structure should feel physical. */
-var SunburstTower3D = class extends Hierarchy3DChart {
-	static meta = {
-		id: "sunburst-tower-3d",
-		name: "3D sunburst tower",
-		family: ChartFamily.Hierarchy,
-		dimension: Dimension.Three,
-		shape: DataShape.Hierarchy,
-		description: "Extrudes the rings of a sunburst into solid segments, stepping by depth or rising with value.",
-		tags: [
-			"extruded sunburst",
-			"radial partition",
-			"ring tower"
-		],
-		sample: (seed) => TreeSamples.broad(seed, 3, 3),
-		variants: {
-			sweep: [
-				PolarSweep.Full,
-				PolarSweep.ThreeQuarter,
-				PolarSweep.Half
-			],
-			profile: [
-				TowerProfile.Dome,
-				TowerProfile.Stairs,
-				TowerProfile.Value
-			],
-			hole: [.25, .5],
-			sort: [HierarchySort.ValueDescending, HierarchySort.Input]
-		}
-	};
-	defaults() {
-		return {
-			...super.defaults(),
-			sweep: PolarSweep.Full,
-			profile: TowerProfile.Dome,
-			hole: .25
-		};
-	}
-	buildTree(ctx) {
-		const { sweep, profile, hole } = this.options;
-		const whole = sweep === PolarSweep.Full ? 2 * Math.PI : sweep === PolarSweep.ThreeQuarter ? 1.5 * Math.PI : Math.PI;
-		const root = partition().size([whole, 1])(this.tree());
-		const levels = Math.max(1, root.height);
-		const inner = hole * RADIUS, band = (RADIUS - inner) / levels;
-		const peak = (node) => max(root.descendants().filter((other) => other.depth === node.depth), (other) => other.value) || 1;
-		const tall = (node) => {
-			if (profile === TowerProfile.Stairs) return .18 + .9 * node.depth / levels;
-			if (profile === TowerProfile.Dome) return .18 + .9 * (levels - node.depth + 1) / levels;
-			return .08 + (node.value ?? 0) / peak(node) * 1.1;
-		};
-		const segments = [];
-		const nodes = root.descendants().filter((node) => node.depth > 0 && node.x1 - node.x0 > .002);
-		for (const node of nodes) {
-			const r0 = inner + band * (node.depth - 1) + GAP / 2, r1 = inner + band * node.depth - GAP / 2;
-			const trim = Math.min((node.x1 - node.x0) / 4, GAP / r1);
-			const a0 = node.x0 + trim, a1 = node.x1 - trim;
-			const shape = new Shape();
-			shape.moveTo(r1 * Math.cos(a0), r1 * Math.sin(a0));
-			shape.absarc(0, 0, r1, a0, a1, false);
-			shape.lineTo(r0 * Math.cos(a1), r0 * Math.sin(a1));
-			shape.absarc(0, 0, r0, a1, a0, true);
-			const geometry = new ExtrudeGeometry(shape, {
-				depth: tall(node),
-				bevelEnabled: false,
-				curveSegments: 18
-			});
-			geometry.rotateX(-Math.PI / 2);
-			const segment = new Mesh(geometry, new MeshStandardMaterial({
-				color: this.style.fill(node),
-				roughness: .6
-			}));
-			segment.position.y = FLOOR;
-			segment.castShadow = segment.receiveShadow = true;
-			ctx.root.add(segment);
-			ctx.pick(segment, () => this.style.tooltip(node));
-			segments.push(segment);
-		}
-		ctx.reveal((progress) => {
-			for (const segment of segments) segment.scale.y = Math.max(.001, progress);
-		});
-	}
-};
-export { SunburstTower3D };