@mstone6969/graph 0.1.0 → 0.2.0

package/dist/charts/mathematical/StrangeAttractor3D.js

@@ -1,251 +0,0 @@
-import { Chart3D } from "../../core/Chart3D.js";
-import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
-import { SampleData } from "../../data/SampleData.js";
-import { MathNumerics } from "./MathNumerics.js";
-import { scaleLinear } from "d3";
-import { BufferGeometry, CatmullRomCurve3, Color, Float32BufferAttribute, InstancedMesh, Line, LineBasicMaterial, Mesh, MeshStandardMaterial, Object3D, SphereGeometry, TubeGeometry, Vector3 } from "three";
-// src/charts/mathematical/StrangeAttractor3D.ts
-var AttractorSystem = /* @__PURE__ */ function(AttractorSystem) {
-	AttractorSystem["Lorenz"] = "lorenz";
-	AttractorSystem["Rossler"] = "rossler";
-	AttractorSystem["Aizawa"] = "aizawa";
-	AttractorSystem["Thomas"] = "thomas";
-	AttractorSystem["Halvorsen"] = "halvorsen";
-	AttractorSystem["ChenLee"] = "chen-lee";
-	return AttractorSystem;
-}({});
-var AttractorRender = /* @__PURE__ */ function(AttractorRender) {
-	AttractorRender["Tube"] = "tube";
-	AttractorRender["Line"] = "line";
-	AttractorRender["Beads"] = "beads";
-	return AttractorRender;
-}({});
-var SYSTEMS = {
-	["lorenz"]: {
-		flow: (x, y, z) => [
-			10 * (y - x),
-			x * (28 - z) - y,
-			x * y - 8 / 3 * z
-		],
-		start: [
-			1,
-			1,
-			20
-		],
-		dt: .006,
-		steps: 6e3
-	},
-	["rossler"]: {
-		flow: (x, y, z) => [
-			-y - z,
-			x + .2 * y,
-			.2 + z * (x - 5.7)
-		],
-		start: [
-			1,
-			1,
-			0
-		],
-		dt: .03,
-		steps: 6e3
-	},
-	["aizawa"]: {
-		flow: (x, y, z) => [
-			(z - .7) * x - 3.5 * y,
-			3.5 * x + (z - .7) * y,
-			.6 + .95 * z - z ** 3 / 3 - (x * x + y * y) * (1 + .25 * z) + .1 * z * x ** 3
-		],
-		start: [
-			.1,
-			0,
-			.1
-		],
-		dt: .012,
-		steps: 7e3
-	},
-	["thomas"]: {
-		flow: (x, y, z) => [
-			Math.sin(y) - .19 * x,
-			Math.sin(z) - .19 * y,
-			Math.sin(x) - .19 * z
-		],
-		start: [
-			1.1,
-			1.1,
-			-.1
-		],
-		dt: .06,
-		steps: 7e3
-	},
-	["halvorsen"]: {
-		flow: (x, y, z) => [
-			-1.4 * x - 4 * y - 4 * z - y * y,
-			-1.4 * y - 4 * z - 4 * x - z * z,
-			-1.4 * z - 4 * x - 4 * y - x * x
-		],
-		start: [
-			-1.5,
-			0,
-			0
-		],
-		dt: .006,
-		steps: 6e3
-	},
-	["chen-lee"]: {
-		flow: (x, y, z) => [
-			5 * x - y * z,
-			-10 * y + x * z,
-			-3.8 * z + x * y / 3
-		],
-		start: [
-			1,
-			1,
-			1
-		],
-		dt: .005,
-		steps: 7e3
-	}
-};
-var SETTLE = 400;
-/** Chaotic flows in three dimensions: trajectories that never repeat yet stay on one shape, with colour tracing time. */
-var StrangeAttractor3D = class extends Chart3D {
-	static meta = {
-		id: "strange-attractor-3d",
-		name: "Strange attractor",
-		family: ChartFamily.Mathematical,
-		dimension: Dimension.Three,
-		shape: DataShape.Function,
-		description: "Integrates a chaotic three-dimensional system and draws its trajectory as a tube, a line or a stream of beads.",
-		tags: [
-			"lorenz",
-			"chaos",
-			"dynamical system",
-			"butterfly"
-		],
-		sample: (seed) => MathNumerics.fit(SampleData.points(seed, 3, 3), "x", "y", [[-.3, .3], [-.3, .3]]).map(([x, y]) => ({
-			x,
-			y
-		})),
-		variants: {
-			system: Object.values(AttractorSystem),
-			render: Object.values(AttractorRender),
-			trajectories: [
-				1,
-				2,
-				3
-			]
-		}
-	};
-	defaults() {
-		return {
-			system: "lorenz",
-			render: "tube",
-			trajectories: 1,
-			x: "x",
-			y: "y",
-			azimuth: 50,
-			elevation: 14,
-			distance: 3.6
-		};
-	}
-	integrate(nudge) {
-		const { flow, start, dt, steps } = SYSTEMS[this.options.system];
-		let [x, y, z] = [
-			start[0] + nudge[0],
-			start[1] + nudge[1],
-			start[2]
-		];
-		const out = [];
-		const add = (a, b, c, k, h) => [
-			a + h * k[0],
-			b + h * k[1],
-			c + h * k[2]
-		];
-		for (let i = 0; i < steps + SETTLE; i++) {
-			const k1 = flow(x, y, z), k2 = flow(...add(x, y, z, k1, dt / 2)), k3 = flow(...add(x, y, z, k2, dt / 2)), k4 = flow(...add(x, y, z, k3, dt));
-			x += dt * (k1[0] + 2 * k2[0] + 2 * k3[0] + k4[0]) / 6;
-			y += dt * (k1[1] + 2 * k2[1] + 2 * k3[1] + k4[1]) / 6;
-			z += dt * (k1[2] + 2 * k2[2] + 2 * k3[2] + k4[2]) / 6;
-			if (!Number.isFinite(x + y + z)) break;
-			if (i >= SETTLE) out.push(new Vector3(x, z, y));
-		}
-		return out;
-	}
-	build(ctx) {
-		const { data, trajectories, render, x, y } = this.options;
-		const paths = Array.from({ length: trajectories }, (_, i) => {
-			const row = data[i];
-			return [Number.isFinite(+row?.[x]) ? +row[x] : i * .1, Number.isFinite(+row?.[y]) ? +row[y] : 0];
-		}).map((nudge) => this.integrate(nudge)).filter((path) => path.length > 1);
-		const all = paths.flat();
-		if (!all.length) return;
-		const span = (axis) => {
-			const values = all.map((p) => p[axis]), a = Math.min(...values.slice(0, 4e3), ...values.slice(-4e3)), b = Math.max(...values.slice(0, 4e3), ...values.slice(-4e3));
-			return [
-				a,
-				b,
-				(a + b) / 2
-			];
-		};
-		const [x0, x1, cx] = span("x"), [y0, y1, cy] = span("y"), [z0, z1, cz] = span("z");
-		const unit = 1.9 / Math.max(x1 - x0, y1 - y0, z1 - z0, 1e-6);
-		const fit = (p) => new Vector3((p.x - cx) * unit, (p.y - cy) * unit, (p.z - cz) * unit);
-		const multi = paths.length > 1;
-		const tint = (path, t) => new Color(multi ? ctx.palette.color(`Start ${path + 1}`) : ctx.palette.sequential(.25 + .75 * t));
-		paths.forEach((raw, index) => {
-			const path = raw.map(fit);
-			const tag = () => ({
-				title: multi ? `Trajectory ${index + 1}` : "Trajectory",
-				rows: [["Steps", path.length]]
-			});
-			if (render === "line") {
-				const geometry = new BufferGeometry().setFromPoints(path);
-				const colors = path.flatMap((_, i) => tint(index, i / path.length).toArray());
-				geometry.setAttribute("color", new Float32BufferAttribute(colors, 3));
-				const line = new Line(geometry, new LineBasicMaterial({ vertexColors: true }));
-				ctx.reveal((progress) => geometry.setDrawRange(0, Math.floor(path.length * progress)), 2.4);
-				ctx.root.add(line);
-			} else if (render === "beads") {
-				const every = Math.ceil(path.length / 1400);
-				const picked = path.filter((_, i) => i % every === 0);
-				const beads = new InstancedMesh(new SphereGeometry(.012, 8, 6), new MeshStandardMaterial({ roughness: .4 }), picked.length);
-				const dummy = new Object3D();
-				beads.castShadow = true;
-				picked.forEach((p, i) => {
-					dummy.position.copy(p);
-					dummy.updateMatrix();
-					beads.setMatrixAt(i, dummy.matrix);
-					beads.setColorAt(i, tint(index, i / picked.length));
-				});
-				ctx.reveal((progress) => {
-					beads.count = Math.max(1, Math.floor(picked.length * progress));
-				}, 2.4);
-				ctx.root.add(beads);
-				ctx.pick(beads, tag);
-			} else {
-				const every = Math.ceil(path.length / 1300);
-				const curve = new CatmullRomCurve3(path.filter((_, i) => i % every === 0));
-				const segments = 1600, sides = 6;
-				const geometry = new TubeGeometry(curve, segments, multi ? .009 : .012, sides, false);
-				const colors = [];
-				for (let i = 0; i <= segments; i++) for (let j = 0; j <= sides; j++) colors.push(...tint(index, i / segments).toArray());
-				geometry.setAttribute("color", new Float32BufferAttribute(colors, 3));
-				const tube = new Mesh(geometry, new MeshStandardMaterial({
-					vertexColors: true,
-					roughness: .42,
-					metalness: .05
-				}));
-				tube.castShadow = true;
-				const total = geometry.index?.count ?? 0;
-				ctx.reveal((progress) => geometry.setDrawRange(0, Math.floor(total * progress)), 2.4);
-				ctx.root.add(tube);
-				ctx.pick(tube, tag);
-			}
-		});
-		const spin = scaleLinear([0, 60], [0, Math.PI * 2]);
-		ctx.onFrame((t) => {
-			if (!this.options.autoRotate) ctx.root.rotation.y = spin(t) * .25;
-		});
-	}
-};
-export { AttractorRender, AttractorSystem, StrangeAttractor3D };

package/dist/charts/proportion/ConeFunnel.js

@@ -1,126 +0,0 @@
-import { Chart3D } from "../../core/Chart3D.js";
-import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
-import { Scales } from "../../core/Scales.js";
-import { ShareData } from "./ShareData.js";
-import { FunnelChart } from "./FunnelChart.js";
-import { CylinderGeometry, Mesh, MeshStandardMaterial, PlaneGeometry, ShadowMaterial } from "three";
-// src/charts/proportion/ConeFunnel.ts
-/** Cross-section of the solid. `Discs` stacks flat cylinders instead of tapering. */
-var ConeProfile = /* @__PURE__ */ function(ConeProfile) {
-	ConeProfile["Cone"] = "cone";
-	ConeProfile["Pyramid"] = "square-pyramid";
-	ConeProfile["Hexagon"] = "hexagonal";
-	ConeProfile["Discs"] = "stacked-discs";
-	return ConeProfile;
-}({});
-var ConeApex = /* @__PURE__ */ function(ConeApex) {
-	ConeApex["Down"] = "apex-down";
-	ConeApex["Up"] = "apex-up";
-	return ConeApex;
-}({});
-var ConeDepth = /* @__PURE__ */ function(ConeDepth) {
-	ConeDepth["Equal"] = "equal-height";
-	ConeDepth["Proportional"] = "proportional-height";
-	return ConeDepth;
-}({});
-var SEGMENTS = {
-	["cone"]: 64,
-	["square-pyramid"]: 4,
-	["hexagonal"]: 6,
-	["stacked-discs"]: 64
-};
-var TALL = 1.7;
-/** A funnel with depth, where each layer's cross-section area follows its stage's value. */
-var ConeFunnel = class extends Chart3D {
-	static meta = {
-		id: "cone-funnel",
-		name: "Cone funnel",
-		family: ChartFamily.Composition,
-		dimension: Dimension.Three,
-		shape: DataShape.Table,
-		description: "Stacks tapered 3D layers whose cross-section area follows each stage of a funnel or pyramid.",
-		tags: [
-			"3d funnel",
-			"3d pyramid",
-			"conversion"
-		],
-		sample: (seed) => FunnelChart.meta.sample(seed),
-		variants: {
-			profile: [
-				"cone",
-				"square-pyramid",
-				"hexagonal",
-				"stacked-discs"
-			],
-			apex: ["apex-down", "apex-up"],
-			depth: ["equal-height", "proportional-height"],
-			gap: [.03, .1]
-		}
-	};
-	defaults() {
-		return {
-			category: "category",
-			value: "value",
-			limit: 8,
-			profile: "cone",
-			apex: "apex-down",
-			depth: "equal-height",
-			gap: .03,
-			distance: 4.9
-		};
-	}
-	build(ctx) {
-		const { data, category, value, limit, profile, apex, depth, gap } = this.options;
-		const shares = ShareData.collect(data, category, value, void 0, limit);
-		ShareData.register(ctx, shares);
-		if (!shares.length) return;
-		const down = apex === "apex-down";
-		const stack = down ? shares : [...shares].reverse();
-		const top = Math.max(...shares.map((share) => share.value));
-		const radius = (amount) => .82 * Math.sqrt(amount / top);
-		const free = TALL - gap * (stack.length - 1);
-		const whole = shares.reduce((total, share) => total + share.value, 0);
-		const floor = free / stack.length / 3;
-		const heights = stack.map((share) => depth === "equal-height" ? free / stack.length : floor + (free - floor * stack.length) * share.value / whole);
-		const discs = profile === "stacked-discs";
-		let y = TALL / 2 - .05;
-		const shadow = new Mesh(new PlaneGeometry(3, 3), new ShadowMaterial({ opacity: .16 }));
-		shadow.rotation.x = -Math.PI / 2;
-		shadow.position.y = -1.7 / 2 - .08;
-		shadow.receiveShadow = true;
-		ctx.root.add(shadow);
-		stack.forEach((share, i) => {
-			const height = heights[i], next = stack[i + 1], before = stack[i - 1];
-			const upper = discs ? radius(share.value) : down ? radius(share.value) : before ? radius(before.value) : Math.max(.02, radius(share.value) * .2);
-			const lower = discs ? radius(share.value) : down ? next ? radius(next.value) : Math.max(.02, radius(share.value) * .55) : radius(share.value);
-			const flat = profile === "square-pyramid" || profile === "hexagonal";
-			const material = new MeshStandardMaterial({
-				color: ShareData.fill(ctx, share),
-				roughness: .5,
-				metalness: .05,
-				flatShading: flat
-			});
-			const mesh = new Mesh(new CylinderGeometry(upper, lower, height, SEGMENTS[profile], 1), material);
-			if (profile === "square-pyramid") mesh.rotation.y = Math.PI / 4;
-			mesh.castShadow = mesh.receiveShadow = true;
-			const centre = y - height / 2;
-			ctx.root.add(mesh);
-			ctx.reveal((t) => {
-				mesh.scale.set(Math.max(.001, t), Math.max(.001, t), Math.max(.001, t));
-				mesh.position.y = centre;
-			}, .7, i * .08);
-			ctx.pick(mesh, () => ({
-				title: share.name,
-				color: ShareData.fill(ctx, share),
-				rows: [[value, share.value], ["Share", ShareData.percent(share.fraction)]]
-			}));
-			ctx.label(`${ShareData.fit(share.name, 80)}  ${Scales.format(share.value, top)}`, [
-				Math.max(upper, lower) + .34,
-				centre,
-				0
-			], "ink", 11);
-			y -= height + gap;
-		});
-	}
-};
-export { ConeApex, ConeDepth, ConeFunnel, ConeProfile };

package/dist/charts/proportion/ExtrudedPieChart.js

@@ -1,123 +0,0 @@
-import { Chart3D } from "../../core/Chart3D.js";
-import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
-import { SampleData } from "../../data/SampleData.js";
-import { ShareData } from "./ShareData.js";
-import { ShareSort } from "./ShareEnums.js";
-import { pie } from "d3";
-import { ExtrudeGeometry, Mesh, MeshStandardMaterial, PlaneGeometry, ShadowMaterial, Shape } from "three";
-// src/charts/proportion/ExtrudedPieChart.ts
-/** `Flat` is one disc; `ByValue` adds height so the largest slice stands tallest. */
-var PieHeight = /* @__PURE__ */ function(PieHeight) {
-	PieHeight["Flat"] = "flat";
-	PieHeight["ByValue"] = "height-by-value";
-	return PieHeight;
-}({});
-var PiePull = /* @__PURE__ */ function(PiePull) {
-	PiePull["None"] = "no-pull";
-	PiePull["Largest"] = "pull-largest";
-	PiePull["All"] = "pull-all";
-	return PiePull;
-}({});
-var RADIUS = .95;
-var FLOOR = -.32;
-var PAD = .012;
-/** A presentation pie with depth. Height can carry the value too, so tilt never hides the ranking. */
-var ExtrudedPieChart = class extends Chart3D {
-	static meta = {
-		id: "extruded-pie",
-		name: "Extruded pie",
-		family: ChartFamily.Composition,
-		dimension: Dimension.Three,
-		shape: DataShape.Table,
-		description: "Extrudes pie or donut slices into solid wedges, optionally raising each slice by its value.",
-		tags: ["3d donut", "extruded pie"],
-		sample: (seed) => SampleData.categories(seed, 6, 1),
-		variants: {
-			hole: [0, .5],
-			rise: ["height-by-value", "flat"],
-			pull: [
-				"no-pull",
-				"pull-largest",
-				"pull-all"
-			],
-			sort: [ShareSort.Descending, ShareSort.Data],
-			labels: [true, false]
-		}
-	};
-	defaults() {
-		return {
-			category: "category",
-			value: "value",
-			limit: 8,
-			sort: ShareSort.Descending,
-			hole: 0,
-			rise: "height-by-value",
-			pull: "no-pull",
-			labels: true,
-			elevation: 34,
-			distance: 4.4
-		};
-	}
-	wedge(from, to, depth) {
-		const inner = this.options.hole * RADIUS;
-		const pad = to - from > PAD * 4 ? PAD : 0;
-		const shape = new Shape();
-		shape.absarc(0, 0, RADIUS, from + pad, to - pad, false);
-		if (inner > 0) shape.absarc(0, 0, inner, to - pad * 2, from + pad * 2, true);
-		else shape.lineTo(0, 0);
-		shape.closePath();
-		const geometry = new ExtrudeGeometry(shape, {
-			depth,
-			bevelEnabled: true,
-			bevelSize: .012,
-			bevelThickness: .012,
-			bevelSegments: 2,
-			curveSegments: Math.max(8, Math.ceil((to - from) * 24))
-		});
-		geometry.rotateX(-Math.PI / 2);
-		return geometry;
-	}
-	build(ctx) {
-		const { data, category, value, limit, sort, rise, pull, labels } = this.options;
-		const shares = ShareData.collect(data, category, value, sort, limit);
-		ShareData.register(ctx, shares);
-		if (!shares.length) return;
-		const top = Math.max(...shares.map((share) => share.value));
-		const slices = pie().value((share) => share.value).sort(null)(shares);
-		const shadow = new Mesh(new PlaneGeometry(3.4, 3.4), new ShadowMaterial({ opacity: .18 }));
-		shadow.rotation.x = -Math.PI / 2;
-		shadow.position.y = FLOOR;
-		shadow.receiveShadow = true;
-		ctx.root.add(shadow);
-		slices.forEach((slice, i) => {
-			const share = slice.data, mid = (slice.startAngle + slice.endAngle) / 2;
-			const depth = rise === "flat" ? .24 : .1 + .42 * (share.value / top);
-			const pulled = pull === "pull-all" || pull === "pull-largest" && share.value === top ? .12 : 0;
-			const mesh = new Mesh(this.wedge(slice.startAngle, slice.endAngle, depth), new MeshStandardMaterial({
-				color: ShareData.fill(ctx, share),
-				roughness: .46,
-				metalness: .05
-			}));
-			mesh.castShadow = mesh.receiveShadow = true;
-			mesh.position.set(Math.cos(mid) * pulled, -.308, -Math.sin(mid) * pulled);
-			ctx.root.add(mesh);
-			ctx.reveal((t) => {
-				mesh.scale.y = Math.max(.001, t);
-			}, .8, i * .06);
-			ctx.pick(mesh, () => ({
-				title: share.name,
-				color: ShareData.fill(ctx, share),
-				rows: [[value, share.value], ["Share", ShareData.percent(share.fraction)]]
-			}));
-			if (labels && slice.endAngle - slice.startAngle > .2) {
-				const reach = RADIUS + pulled + .14;
-				ctx.label(ShareData.percent(share.fraction), [
-					Math.cos(mid) * reach,
-					FLOOR + depth + .02,
-					-Math.sin(mid) * reach
-				], "ink", 11);
-			}
-		});
-	}
-};
-export { ExtrudedPieChart, PieHeight, PiePull };

package/dist/charts/scatter/BeeswarmScatter.js

@@ -1,151 +0,0 @@
-import { ChartFamily, DataShape, Dimension, Orientation, ScaleKind } from "../../core/enums.js";
-import { SampleData } from "../../data/SampleData.js";
-import { CategoryScatterBase } from "./CategoryScatterBase.js";
-import { ascending, forceCollide, forceSimulation, forceX, forceY, max, scaleSqrt } from "d3";
-// src/charts/scatter/BeeswarmScatter.ts
-var BeeswarmLayout = /* @__PURE__ */ function(BeeswarmLayout) {
-	BeeswarmLayout["Dodge"] = "dodge";
-	BeeswarmLayout["Force"] = "force";
-	BeeswarmLayout["Stacked"] = "stacked-dots";
-	return BeeswarmLayout;
-}({});
-var BeeswarmSide = /* @__PURE__ */ function(BeeswarmSide) {
-	BeeswarmSide["Both"] = "two-sided";
-	BeeswarmSide["One"] = "one-sided";
-	return BeeswarmSide;
-}({});
-var BeeswarmLanes = /* @__PURE__ */ function(BeeswarmLanes) {
-	BeeswarmLanes["PerGroup"] = "per-group";
-	BeeswarmLanes["Shared"] = "shared";
-	return BeeswarmLanes;
-}({});
-/** Each point nudged just far enough to avoid its neighbours, so the swarm's shape is the distribution. */
-var BeeswarmScatter = class extends CategoryScatterBase {
-	static meta = {
-		id: "beeswarm-scatter",
-		name: "Beeswarm scatter",
-		family: ChartFamily.Distribution,
-		dimension: Dimension.Two,
-		shape: DataShape.Table,
-		description: "Packs points along one measure without overlap, keeping each observation individually visible.",
-		tags: [
-			"swarm",
-			"dodge",
-			"wilkinson dot plot"
-		],
-		sample: (seed) => SampleData.points(seed, 120, 3).map((row) => ({
-			group: row.group,
-			value: row.y,
-			size: row.size
-		})),
-		variants: {
-			orientation: [Orientation.Horizontal, Orientation.Vertical],
-			layout: [
-				"dodge",
-				"force",
-				"stacked-dots"
-			],
-			side: ["two-sided", "one-sided"],
-			lanes: ["per-group", "shared"],
-			sized: [false, true],
-			scale: [ScaleKind.Linear, ScaleKind.Log]
-		},
-		valid: (v) => !(v.layout === "stacked-dots" && v.sized) && !(v.layout === "force" && v.side === "one-sided")
-	};
-	defaults() {
-		return {
-			...super.defaults(),
-			orientation: Orientation.Horizontal,
-			layout: "dodge",
-			side: "two-sided",
-			lanes: "per-group",
-			sized: false,
-			radius: 3.5
-		};
-	}
-	/** Greedy dodge: sorted by value, each dot takes the free offset closest to the lane axis. */
-	dodge(bees) {
-		const placed = [];
-		const oneSided = this.options.side === "one-sided";
-		for (const bee of [...bees].sort((a, b) => ascending(a.along, b.along))) {
-			const near = placed.filter((other) => Math.abs(other.along - bee.along) < other.radius + bee.radius + 1);
-			bee.offset = [0, ...near.flatMap((other) => {
-				const gap = other.radius + bee.radius + 1;
-				const rise = Math.sqrt(Math.max(0, gap ** 2 - (other.along - bee.along) ** 2));
-				return [other.offset + rise, other.offset - rise];
-			})].filter((offset) => !oneSided || offset >= 0).sort((a, b) => Math.abs(a) - Math.abs(b)).find((offset) => near.every((other) => (other.along - bee.along) ** 2 + (other.offset - offset) ** 2 >= (other.radius + bee.radius + .9) ** 2)) ?? 0;
-			placed.push(bee);
-		}
-	}
-	force(bees) {
-		const nodes = bees.map((bee) => ({
-			x: bee.along,
-			y: 0,
-			home: bee.along,
-			r: bee.radius + 1
-		}));
-		forceSimulation(nodes).stop().force("x", forceX((d) => d.home).strength(1)).force("y", forceY(0).strength(.08)).force("collide", forceCollide((d) => d.r)).tick(160);
-		nodes.forEach((node, i) => {
-			bees[i].along = node.x;
-			bees[i].offset = node.y;
-		});
-	}
-	/** Wilkinson dot plot: dots snap into value bins and stack from the axis. */
-	stack(bees) {
-		const step = (this.options.radius + 1) * 2;
-		const columns = /* @__PURE__ */ new Map();
-		for (const bee of [...bees].sort((a, b) => ascending(a.along, b.along))) {
-			const bin = Math.round(bee.along / step), height = columns.get(bin) ?? 0;
-			columns.set(bin, height + 1);
-			bee.along = bin * step;
-			bee.offset = (this.options.side === "one-sided" ? height : Math.ceil(height / 2) * (height % 2 ? 1 : -1)) * step;
-		}
-	}
-	arrange(bees) {
-		const { layout } = this.options;
-		if (layout === "force") this.force(bees);
-		else if (layout === "stacked-dots") this.stack(bees);
-		else this.dodge(bees);
-	}
-	laneOf(group) {
-		return this.options.lanes === "shared" ? "" : group;
-	}
-	plotLanes(ctx, axes, lanes) {
-		const vertical = this.vertical, oneSided = this.options.side === "one-sided";
-		const all = lanes.flatMap((lane) => lane.points);
-		all.forEach((point) => ctx.palette.color(point.group));
-		const area = scaleSqrt([0, max(all, (point) => point.size) || 1], [1.5, this.options.radius * 2.2]);
-		const radius = (point) => this.options.sized ? area(point.size) : this.options.radius;
-		const bees = lanes.flatMap((lane) => {
-			const base = lane.center + (oneSided ? (vertical ? -1 : 1) * (lane.breadth / 2 - 4) : 0);
-			const swarm = lane.points.map((point) => ({
-				...point,
-				along: axes.value(point.value),
-				radius: radius(point),
-				offset: 0,
-				center: base
-			}));
-			this.arrange(swarm);
-			const reach = Math.max(1, ...swarm.map((bee) => Math.abs(bee.offset) + bee.radius));
-			const squeeze = Math.min(1, (oneSided ? lane.breadth - 8 : lane.breadth / 2) / reach);
-			return swarm.map((bee) => ({
-				...bee,
-				offset: (oneSided ? (vertical ? 1 : -1) * Math.abs(bee.offset) : bee.offset) * squeeze
-			}));
-		});
-		const cx = (d) => vertical ? d.center + d.offset : d.along;
-		const cy = (d) => vertical ? d.along : d.center + d.offset;
-		const dots = ctx.marks("dots", "circle", bees, (d) => d.index).attr("fill", (d) => ctx.palette.color(d.group)).attr("stroke", ctx.theme.surface).attr("stroke-width", 1);
-		ctx.set(dots, {
-			cx,
-			cy,
-			r: (d) => d.radius
-		}, {
-			cx: (d) => vertical ? d.center : d.along,
-			cy: (d) => vertical ? d.along : d.center,
-			r: 0
-		}, 1);
-		ctx.hover(dots, (d) => this.tooltip(ctx, d));
-	}
-};
-export { BeeswarmLanes, BeeswarmLayout, BeeswarmScatter, BeeswarmSide };

package/dist/charts/scatter/BinnedScatterBase.js

@@ -1,51 +0,0 @@
-import { ScatterBase } from "./ScatterBase.js";
-// src/charts/scatter/BinnedScatterBase.ts
-var BinEncoding = /* @__PURE__ */ function(BinEncoding) {
-	BinEncoding["Color"] = "color";
-	BinEncoding["Size"] = "size";
-	BinEncoding["Both"] = "color-and-size";
-	return BinEncoding;
-}({});
-var BinCount = /* @__PURE__ */ function(BinCount) {
-	BinCount["Linear"] = "linear-count";
-	BinCount["Sqrt"] = "sqrt-count";
-	BinCount["Log"] = "log-count";
-	return BinCount;
-}({});
-/** Shared count-to-mark mapping for charts that aggregate points into cells. */
-var BinnedScatterBase = class extends ScatterBase {
-	defaults() {
-		return {
-			...super.defaults(),
-			encoding: "color",
-			count: "linear-count",
-			raw: false
-		};
-	}
-	/** Share of the peak in 0..1 after the count transform. */
-	share(count, peak) {
-		const { count: kind } = this.options;
-		if (kind === "log-count") return Math.log1p(count) / Math.log1p(peak);
-		if (kind === "sqrt-count") return Math.sqrt(count / peak);
-		return count / peak;
-	}
-	shade(ctx, share) {
-		return ctx.palette.sequential(this.options.encoding === "size" ? .62 : .14 + share * .86);
-	}
-	/** Linear size scale of a cell, so mark area stays proportional to the share. */
-	extent(share) {
-		return this.options.encoding === "color" ? 1 : Math.sqrt(share);
-	}
-	drawRaw(ctx, points) {
-		const dots = ctx.marks("raw", "circle", this.options.raw ? points : [], (d) => d.index).attr("fill", ctx.theme.inkMuted).attr("fill-opacity", .5);
-		ctx.set(dots, {
-			cx: (d) => d.px,
-			cy: (d) => d.py,
-			r: 1.5
-		});
-	}
-	legendItems() {
-		return [];
-	}
-};
-export { BinCount, BinEncoding, BinnedScatterBase };