@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/threenetwork/Sunburst3DChart.js

@@ -0,0 +1,103 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { Hierarchy3DBase } from "./Hierarchy3DBase.js";
+import { NetworkMarks3D } from "./NetworkMarks3D.js";
+import { RingSegment3D } from "./RingSegment3D.js";
+import { partition } from "d3";
+import { Vector3 } from "three";
+// src/charts/threenetwork/Sunburst3DChart.ts
+/** The surface the rings are laid on. */
+var SunburstShape3D = /* @__PURE__ */ function(SunburstShape3D) {
+	SunburstShape3D["Stepped"] = "stepped";
+	SunburstShape3D["Flat"] = "flat";
+	SunburstShape3D["Dome"] = "dome";
+	SunburstShape3D["Funnel"] = "funnel";
+	return SunburstShape3D;
+}({});
+var SunburstExtrude3D = /* @__PURE__ */ function(SunburstExtrude3D) {
+	SunburstExtrude3D["Uniform"] = "uniform";
+	SunburstExtrude3D["Share"] = "share";
+	return SunburstExtrude3D;
+}({});
+var SunburstSweep3D = /* @__PURE__ */ function(SunburstSweep3D) {
+	SunburstSweep3D["Full"] = "full";
+	SunburstSweep3D["Half"] = "half";
+	return SunburstSweep3D;
+}({});
+var PAD = .008;
+/** Sunburst with relief: rings of a hierarchy on a plane, dome or funnel, where thickness can add a second reading. */
+var Sunburst3DChart = class extends Hierarchy3DBase {
+	static meta = {
+		id: "sunburst-3d",
+		name: "3D sunburst",
+		family: ChartFamily.Hierarchy,
+		dimension: Dimension.Three,
+		shape: DataShape.Hierarchy,
+		description: "Shows part-to-whole across levels as extruded rings, with depth readable from the rings stacked outwards.",
+		tags: [
+			"sunburst",
+			"ring chart",
+			"partition"
+		],
+		sample: (seed) => SampleData.tree(seed, 3, 5),
+		variants: {
+			shape: Object.values(SunburstShape3D),
+			extrude: Object.values(SunburstExtrude3D),
+			sweep: Object.values(SunburstSweep3D),
+			hole: [0, .2]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			shape: "stepped",
+			extrude: "uniform",
+			sweep: "full",
+			hole: 0,
+			elevation: 44,
+			distance: 4.2
+		};
+	}
+	surface() {
+		const { shape } = this.options;
+		if (shape === "dome") return (angle, radius, lift) => {
+			const polar = Math.min(radius, 1) * Math.PI * .5, reach = 1 + lift;
+			return new Vector3(Math.sin(polar) * Math.cos(angle) * reach, Math.cos(polar) * reach * .86 - .42, Math.sin(polar) * Math.sin(angle) * reach);
+		};
+		if (shape === "funnel") return (angle, radius, lift) => new Vector3(radius * Math.cos(angle), radius * .9 - .5 + lift, radius * Math.sin(angle));
+		return (angle, radius, lift) => new Vector3(radius * Math.cos(angle), lift - .25, radius * Math.sin(angle));
+	}
+	build(ctx) {
+		const { shape, extrude, sweep, hole } = this.options;
+		const root = partition().size([1, 1])(this.tree(true));
+		if (!root.value) return;
+		const marks = new NetworkMarks3D(ctx);
+		const span = sweep === "full" ? Math.PI * 2 : Math.PI;
+		const surface = this.surface(), height = root.height + 1;
+		const firstRing = hole > 0 ? root.y1 : 0;
+		const radial = (y) => hole + (1 - hole) * (y - firstRing) / (1 - firstRing);
+		const shown = root.descendants().filter((node) => (hole > 0 ? node.depth > 0 : true) && node.x1 > node.x0);
+		marks.lofts(shown.map((node) => {
+			const share = node.parent ? (node.value ?? 0) / (node.parent.value || 1) : 1;
+			const thick = extrude === "share" ? .03 + share * .3 : .07;
+			const stair = shape === "stepped" ? (height - node.depth - 1) / height * .62 : 0;
+			const pad = node.x1 - node.x0 === 1 && sweep === "full" ? 0 : Math.min(PAD / Math.max(radial(node.y1), .1), (node.x1 - node.x0) * span / 4);
+			const a0 = node.x0 * span + pad, a1 = node.x1 * span - pad;
+			return {
+				rings: RingSegment3D.rings(surface, a0, a1, radial(node.y0) + (node.depth ? PAD : 0), radial(node.y1) - PAD, shape === "dome" ? 0 : stair * 0, shape === "dome" ? thick * .5 : stair + thick),
+				color: this.branchColor(ctx, marks, node),
+				tip: this.tipOf(node)
+			};
+		}), { sharp: true });
+		for (const node of root.children ?? []) if (node.x1 - node.x0 > .1) {
+			const crest = shape === "stepped" ? (height - node.depth - 1) / height * .62 + .09 : .2;
+			const point = surface((node.x0 + node.x1) / 2 * span, radial(node.y0 * .25 + node.y1 * .75), crest);
+			ctx.label(this.nameOf(node), [
+				point.x,
+				point.y,
+				point.z
+			], "ink", 10);
+		}
+	}
+};
+export { Sunburst3DChart, SunburstExtrude3D, SunburstShape3D, SunburstSweep3D };

package/dist/charts/threenetwork/Temporal3DBase.js

@@ -0,0 +1,22 @@
+import { Chart3D } from "../../core/Chart3D.js";
+// src/charts/threenetwork/Temporal3DBase.ts
+var DAY = 864e5;
+/** Shared date handling for time-on-a-shape charts: accepts Dates, ISO strings and epoch numbers, and drops anything else. */
+var Temporal3DBase = class extends Chart3D {
+	time(cell) {
+		if (cell == null || cell === "") return null;
+		const value = cell instanceof Date ? cell.getTime() : new Date(cell).getTime();
+		return Number.isFinite(value) ? value : null;
+	}
+	/** Rows with a usable date in `key`, oldest first, paired with that time. */
+	dated(key) {
+		return (this.options.data ?? []).flatMap((row) => {
+			const time = this.time(row[key]);
+			return time === null ? [] : [{
+				row,
+				time
+			}];
+		}).sort((a, b) => a.time - b.time);
+	}
+};
+export { DAY, Temporal3DBase };

package/dist/charts/threenetwork/Timeline3DChart.js

@@ -0,0 +1,168 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { NetworkMarks3D } from "./NetworkMarks3D.js";
+import { Path3D } from "./Path3D.js";
+import { DAY, Temporal3DBase } from "./Temporal3DBase.js";
+import { scaleLinear, scaleSqrt } from "d3";
+import { BoxGeometry, CylinderGeometry, SphereGeometry, Vector3 } from "three";
+// src/charts/threenetwork/Timeline3DChart.ts
+/** The route time follows. */
+var TimelinePath3D = /* @__PURE__ */ function(TimelinePath3D) {
+	TimelinePath3D["Road"] = "road";
+	TimelinePath3D["Arc"] = "arc";
+	TimelinePath3D["Ring"] = "ring";
+	TimelinePath3D["Wave"] = "wave";
+	return TimelinePath3D;
+}({});
+var TimelineMark3D = /* @__PURE__ */ function(TimelineMark3D) {
+	TimelineMark3D["Stem"] = "stem";
+	TimelineMark3D["Pillar"] = "pillar";
+	TimelineMark3D["Disc"] = "disc";
+	return TimelineMark3D;
+}({});
+var BASE = -.45;
+/** Events along a route through space: for a sequence where magnitude and category both matter. */
+var Timeline3DChart = class extends Temporal3DBase {
+	static meta = {
+		id: "timeline-3d",
+		name: "3D timeline",
+		family: ChartFamily.Temporal,
+		dimension: Dimension.Three,
+		shape: DataShape.Table,
+		description: "Stands dated events along a road, arc or ring, with height or area showing each event's size.",
+		tags: [
+			"timeline",
+			"events",
+			"chronology"
+		],
+		sample: (seed) => SampleData.tasks(seed, 26).map(({ task, start, end, group }) => ({
+			event: task,
+			date: start,
+			group,
+			value: Math.round((end.getTime() - start.getTime()) / DAY)
+		})),
+		variants: {
+			path: Object.values(TimelinePath3D),
+			mark: Object.values(TimelineMark3D),
+			lanes: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			date: "date",
+			group: "group",
+			value: "value",
+			name: "event",
+			path: "road",
+			mark: "stem",
+			lanes: true,
+			azimuth: 20,
+			elevation: 26,
+			distance: 4.2
+		};
+	}
+	/** Point on the route at `u`, pushed sideways by `side`. */
+	route(u, side) {
+		switch (this.options.path) {
+			case "ring": {
+				const angle = u * Math.PI * 1.9 - Math.PI / 2, r = .8 + side;
+				return new Vector3(Math.cos(angle) * r, BASE, Math.sin(angle) * r);
+			}
+			case "arc": {
+				const angle = Math.PI * (1 - u), r = .92 + side;
+				return new Vector3(Math.cos(angle) * r, BASE, .5 - Math.sin(angle) * r);
+			}
+			case "wave": {
+				const x = u * 2 - 1, phase = u * Math.PI * 3, slope = Math.cos(phase) * 1.35, length = Math.hypot(1, slope);
+				return new Vector3(x - slope / length * side, BASE, Math.sin(phase) * .45 + side / length);
+			}
+			default: return new Vector3(u * 2 - 1, BASE, side);
+		}
+	}
+	build(ctx) {
+		const { date, group, value, name, mark, lanes } = this.options;
+		const events = this.dated(date);
+		if (!events.length) return;
+		const marks = new NetworkMarks3D(ctx);
+		const groups = [...new Set(events.map(({ row }) => String(row[group] ?? "All")))];
+		const first = events[0].time, last = events.at(-1).time;
+		const along = scaleLinear([first, last === first ? first + 1 : last], [.02, .98]);
+		const magnitude = (row) => Math.abs(+row[value] || 0);
+		const peak = Math.max(...events.map(({ row }) => magnitude(row)), 1e-6);
+		const tall = scaleLinear([0, peak], [0, 1.2]), area = scaleSqrt([0, peak], [0, .13]);
+		const laneWidth = .26;
+		const side = (key) => lanes && groups.length > 1 ? (groups.indexOf(key) / (groups.length - 1) - .5) * laneWidth * groups.length * .8 : 0;
+		const offsets = lanes ? groups.map(side) : [0];
+		const steps = 96;
+		marks.batch(offsets.map((offset) => ({
+			rings: Path3D.tube(Array.from({ length: 97 }, (_, i) => this.route(i / steps, offset)), lanes ? .009 : .022, 8),
+			color: ctx.theme.axis
+		})), {}, { roughness: .9 });
+		const seated = events.map(({ row, time }) => {
+			const key = String(row[group] ?? "All");
+			const at = this.route(along(time), side(key)), color = ctx.palette.color(key);
+			return {
+				row,
+				at,
+				color,
+				height: tall(magnitude(row)),
+				tip: {
+					title: String(row[name] ?? key),
+					color,
+					rows: [["Date", new Date(time).toISOString().slice(0, 10)], [String(value), +row[value] || 0]]
+				}
+			};
+		});
+		const standing = (width) => seated.map(({ at, color, height, tip }) => ({
+			at: at.clone().setY(BASE + height / 2),
+			size: new Vector3(width, height, width),
+			color,
+			tip
+		}));
+		if (mark === "stem") {
+			marks.instances(new CylinderGeometry(1, 1, 1, 8), standing(.007), {
+				rise: true,
+				shadow: false
+			});
+			marks.instances(new SphereGeometry(1, 16, 12), seated.map(({ at, color, height, tip }) => ({
+				at: at.clone().setY(BASE + height),
+				size: .03,
+				color,
+				tip
+			})), {
+				roughness: .35,
+				delay: .4
+			});
+		} else if (mark === "pillar") marks.instances(new BoxGeometry(1, 1, 1), standing(.05), { rise: true });
+		else marks.instances(new CylinderGeometry(1, 1, 1, 40), seated.map(({ row, at, color, tip }) => {
+			const r = area(magnitude(row));
+			return {
+				at: at.clone().setY(-.438),
+				size: new Vector3(r, .024, r),
+				color,
+				tip
+			};
+		}), {
+			opacity: .9,
+			roughness: .5
+		});
+		const start = this.route(.02, offsets[0]), end = this.route(.98, offsets[0]);
+		const day = (time) => new Date(time).toISOString().slice(0, 10);
+		if (start.distanceTo(end) < .6) return void ctx.label(last > first ? `${day(first)} → ${day(last)}` : day(first), [
+			0,
+			-.55,
+			1.06
+		], "muted", 10);
+		ctx.label(day(first), [
+			start.x,
+			-.55,
+			start.z
+		], "muted", 10);
+		if (last > first) ctx.label(day(last), [
+			end.x,
+			-.55,
+			end.z
+		], "muted", 10);
+	}
+};
+export { Timeline3DChart, TimelineMark3D, TimelinePath3D };

package/dist/charts/threenetwork/Tree3DChart.js

@@ -0,0 +1,124 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { Hierarchy3DBase } from "./Hierarchy3DBase.js";
+import { NetworkMarks3D } from "./NetworkMarks3D.js";
+import { Path3D } from "./Path3D.js";
+import { cluster, tree } from "d3";
+import { SphereGeometry, Vector3 } from "three";
+// src/charts/threenetwork/Tree3DChart.ts
+/** The surface a tree is unrolled onto. */
+var TreeSurface3D = /* @__PURE__ */ function(TreeSurface3D) {
+	TreeSurface3D["Funnel"] = "funnel";
+	TreeSurface3D["Wall"] = "wall";
+	TreeSurface3D["Dome"] = "dome";
+	TreeSurface3D["Cylinder"] = "cylinder";
+	return TreeSurface3D;
+}({});
+var TreeAlignment3D = /* @__PURE__ */ function(TreeAlignment3D) {
+	TreeAlignment3D["Tidy"] = "tidy";
+	TreeAlignment3D["Dendrogram"] = "dendrogram";
+	return TreeAlignment3D;
+}({});
+var TreeLink3D = /* @__PURE__ */ function(TreeLink3D) {
+	TreeLink3D["Curve"] = "curve";
+	TreeLink3D["Straight"] = "straight";
+	TreeLink3D["Elbow"] = "elbow";
+	return TreeLink3D;
+}({});
+var TreeNodeSize3D = /* @__PURE__ */ function(TreeNodeSize3D) {
+	TreeNodeSize3D["Value"] = "value";
+	TreeNodeSize3D["Uniform"] = "uniform";
+	return TreeNodeSize3D;
+}({});
+/** A node-link tree wrapped on a surface: for structure too wide to fit on a flat page. */
+var Tree3DChart = class extends Hierarchy3DBase {
+	static meta = {
+		id: "tree-3d",
+		name: "3D tree",
+		family: ChartFamily.Hierarchy,
+		dimension: Dimension.Three,
+		shape: DataShape.Hierarchy,
+		description: "Wraps a tidy tree or dendrogram onto a surface so deep, wide hierarchies stay untangled.",
+		tags: [
+			"tree",
+			"dendrogram",
+			"radial tree",
+			"hierarchy"
+		],
+		sample: (seed) => SampleData.tree(seed, 3, 5),
+		variants: {
+			surface: Object.values(TreeSurface3D),
+			alignment: Object.values(TreeAlignment3D),
+			linkShape: Object.values(TreeLink3D),
+			nodeSize: Object.values(TreeNodeSize3D)
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			surface: "funnel",
+			alignment: "tidy",
+			linkShape: "curve",
+			nodeSize: "value",
+			distance: 4.6
+		};
+	}
+	/** Maps layout space (`u` across the tree, `v` root to leaf) onto the chosen surface. */
+	mapper() {
+		const angle = (u) => u * Math.PI * 2;
+		switch (this.options.surface) {
+			case "wall": return (u, v) => new Vector3(u * 2.2 - 1.1, .85 - v * 1.75, Math.sin(u * Math.PI * 4) * .28 * v);
+			case "dome": return (u, v) => {
+				const polar = v * Math.PI * .52;
+				return new Vector3(Math.sin(polar) * Math.cos(angle(u)), Math.cos(polar) * 1.05 - .45, Math.sin(polar) * Math.sin(angle(u)));
+			};
+			case "cylinder": return (u, v) => {
+				const r = v < .25 ? v * 4 * .8 : .8;
+				return new Vector3(r * Math.cos(angle(u)), .95 - v * 1.85, r * Math.sin(angle(u)));
+			};
+			default: return (u, v) => new Vector3(v * Math.cos(angle(u)), .75 - v * 1.5, v * Math.sin(angle(u)));
+		}
+	}
+	route(a, b, map) {
+		const { linkShape } = this.options;
+		const steps = 14;
+		return Array.from({ length: 15 }, (_, i) => {
+			const t = i / steps;
+			if (linkShape === "straight") return map(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t);
+			if (linkShape === "curve") return map(a.x + (b.x - a.x) * (t * t * (3 - 2 * t)), a.y + (b.y - a.y) * t);
+			if (t < .4) return map(a.x, a.y + (b.y - a.y) * (t / .4) * .5);
+			if (t < .6) return map(a.x + (b.x - a.x) * ((t - .4) / .2), a.y + (b.y - a.y) * .5);
+			return map(b.x, a.y + (b.y - a.y) * (.5 + (t - .6) / .4 * .5));
+		});
+	}
+	build(ctx) {
+		const { alignment, nodeSize } = this.options;
+		const marks = new NetworkMarks3D(ctx);
+		const root = this.tree();
+		if (!root.children?.length && !root.value) return;
+		const placed = (alignment === "tidy" ? tree() : cluster()).size([1, 1])(root);
+		const map = this.mapper();
+		const links = placed.links();
+		const breadth = Math.cbrt(Math.max(placed.descendants().length, 1));
+		marks.batch(links.map(({ source, target }) => ({
+			rings: Path3D.tube(this.route(source, target, map), .0065, 5),
+			color: marks.faded(this.branchColor(ctx, marks, target), .2)
+		})), {}, { roughness: .8 });
+		const top = Math.max(1, placed.value ?? 1);
+		marks.instances(new SphereGeometry(1, 18, 12), placed.descendants().map((node) => ({
+			at: map(node.x, node.y),
+			size: (nodeSize === "uniform" ? .03 : Math.max(.02, .095 * Math.cbrt((node.value ?? 0) / top))) * Math.min(1, 4.2 / breadth),
+			color: this.branchColor(ctx, marks, node),
+			tip: this.tipOf(node)
+		})), { roughness: .35 });
+		for (const branch of placed.children ?? []) {
+			const point = map(branch.x, branch.y);
+			ctx.label(this.nameOf(branch), [
+				point.x,
+				point.y + .09,
+				point.z
+			], "secondary", 10);
+		}
+	}
+};
+export { Tree3DChart, TreeAlignment3D, TreeLink3D, TreeNodeSize3D, TreeSurface3D };

package/dist/charts/threenetwork/Treemap3DChart.js

@@ -0,0 +1,98 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { Hierarchy3DBase } from "./Hierarchy3DBase.js";
+import { NetworkMarks3D } from "./NetworkMarks3D.js";
+import { scaleLinear, treemap, treemapBinary, treemapDice, treemapSlice, treemapSliceDice, treemapSquarify } from "d3";
+import { BoxGeometry, Vector3 } from "three";
+// src/charts/threenetwork/Treemap3DChart.ts
+var TreemapTile3D = /* @__PURE__ */ function(TreemapTile3D) {
+	TreemapTile3D["Squarify"] = "squarify";
+	TreemapTile3D["Binary"] = "binary";
+	TreemapTile3D["Slice"] = "slice";
+	TreemapTile3D["Dice"] = "dice";
+	TreemapTile3D["SliceDice"] = "slice-dice";
+	return TreemapTile3D;
+}({});
+/** What the vertical dimension carries. */
+var TreemapRelief3D = /* @__PURE__ */ function(TreemapRelief3D) {
+	TreemapRelief3D["Terraced"] = "terraced";
+	TreemapRelief3D["Value"] = "value";
+	TreemapRelief3D["Flat"] = "flat";
+	return TreemapRelief3D;
+}({});
+var TreemapOrder3D = /* @__PURE__ */ function(TreemapOrder3D) {
+	TreemapOrder3D["Value"] = "value";
+	TreemapOrder3D["Input"] = "input";
+	return TreemapOrder3D;
+}({});
+var TILES = {
+	["squarify"]: treemapSquarify,
+	["binary"]: treemapBinary,
+	["slice"]: treemapSlice,
+	["dice"]: treemapDice,
+	["slice-dice"]: treemapSliceDice
+};
+var BASE = -.36;
+var STEP = .13;
+/** Treemap with height: area shows the measure, and height shows nesting or a second measure. */
+var Treemap3DChart = class extends Hierarchy3DBase {
+	static meta = {
+		id: "treemap-3d",
+		name: "3D treemap",
+		family: ChartFamily.Hierarchy,
+		dimension: Dimension.Three,
+		shape: DataShape.Hierarchy,
+		description: "Tiles a hierarchy by value and raises the tiles, adding nesting depth or a second measure as height.",
+		tags: [
+			"treemap",
+			"terraced treemap",
+			"cushion"
+		],
+		sample: (seed) => SampleData.tree(seed, 3, 5),
+		variants: {
+			tile: Object.values(TreemapTile3D),
+			relief: Object.values(TreemapRelief3D),
+			order: Object.values(TreemapOrder3D),
+			gutter: [.014, .034]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			tile: "squarify",
+			relief: "terraced",
+			order: "value",
+			gutter: .014,
+			elevation: 34,
+			distance: 4.3
+		};
+	}
+	build(ctx) {
+		const { tile, relief, order, heightBy, gutter } = this.options;
+		const root = this.tree(order === "value");
+		if (!root.value) return;
+		const marks = new NetworkMarks3D(ctx);
+		const placed = treemap().tile(TILES[tile]).size([2, 2]).paddingInner(gutter).paddingOuter(gutter * 1.2).round(false)(root);
+		const measure = (node) => Math.max(0, +node.data[heightBy ?? this.options.value] || 0);
+		const leaves = placed.leaves();
+		const lift = scaleLinear([0, Math.max(...leaves.map(measure), 1e-6)], [.02, 1.15]);
+		const nodes = relief === "terraced" ? placed.descendants().filter((node) => node.depth) : relief === "value" ? [...placed.descendants().filter((node) => node.depth === 1), ...leaves] : leaves;
+		const top = (node) => relief === "terraced" ? BASE + node.depth * STEP : relief === "flat" ? -.27999999999999997 : node.children ? -.32999999999999996 : -.32999999999999996 + lift(measure(node));
+		const bottom = (node) => relief === "terraced" ? BASE + (node.depth - 1) * STEP : relief === "value" && !node.children ? -.32999999999999996 : BASE;
+		marks.instances(new BoxGeometry(1, 1, 1), nodes.filter((node) => node.x1 > node.x0 && node.y1 > node.y0).map((node) => ({
+			at: new Vector3((node.x0 + node.x1) / 2 - 1, (top(node) + bottom(node)) / 2, (node.y0 + node.y1) / 2 - 1),
+			size: new Vector3(node.x1 - node.x0, top(node) - bottom(node), node.y1 - node.y0),
+			color: this.branchColor(ctx, marks, node),
+			tip: this.tipOf(node)
+		})), {
+			rise: true,
+			roughness: .6
+		});
+		for (const branch of placed.children ?? []) if (branch.x1 - branch.x0 > .3) ctx.label(this.nameOf(branch), [
+			(branch.x0 + branch.x1) / 2 - 1,
+			top(branch) + .08,
+			(branch.y0 + branch.y1) / 2 - 1
+		], "ink", 10);
+	}
+};
+export { Treemap3DChart, TreemapOrder3D, TreemapRelief3D, TreemapTile3D };

package/dist/charts/threenetwork/enums.js

@@ -0,0 +1,9 @@
+// src/charts/threenetwork/enums.ts
+/** How a node's sphere is sized. Volume, not radius, follows the measure. */
+var NodeSizing3D = /* @__PURE__ */ function(NodeSizing3D) {
+	NodeSizing3D["Degree"] = "degree";
+	NodeSizing3D["Value"] = "value";
+	NodeSizing3D["Uniform"] = "uniform";
+	return NodeSizing3D;
+}({});
+export { NodeSizing3D };

package/dist/charts/threenetwork/index.js

@@ -0,0 +1,56 @@
+import { NodeSizing3D } from "./enums.js";
+import { LabelSpacer3D } from "./LabelSpacer3D.js";
+import { Path3D } from "./Path3D.js";
+import { Graph3DBase } from "./Graph3DBase.js";
+import { Loft } from "./Loft.js";
+import { NetworkMarks3D } from "./NetworkMarks3D.js";
+import { Arc3DDiagram, ArcOrder3D, ArcPlane3D, ArcProfile3D } from "./Arc3DDiagram.js";
+import { DAY, Temporal3DBase } from "./Temporal3DBase.js";
+import { Calendar3DChart, CalendarAggregate3D, CalendarLayout3D, CalendarMark3D, CalendarWeekStart3D } from "./Calendar3DChart.js";
+import { RingSegment3D } from "./RingSegment3D.js";
+import { Chord3DChart, ChordArc3D, ChordOrder3D, ChordRim3D } from "./Chord3DChart.js";
+import { ForceLayout3D } from "./ForceLayout3D.js";
+import { Hierarchy3DBase } from "./Hierarchy3DBase.js";
+import { CirclePack3DChart, PackForm3D, PackLift3D, PackParents3D } from "./CirclePack3DChart.js";
+import { City3DChart, CityBuilding3D, CityLots3D, CityTerrain3D } from "./City3DChart.js";
+import { ConeAxis3D, ConeLink3D, ConeRadius3D, ConeSpacing3D, ConeTreeChart } from "./ConeTreeChart.js";
+import { Dag3DChart, DagFlow3D, DagLayer3D, DagRoute3D } from "./Dag3DChart.js";
+import { Force3DGraph, ForceGraphLayout3D, ForceLinkStyle3D } from "./Force3DGraph.js";
+import { Gantt3DChart, GanttHeight3D, GanttOrder3D, GanttStack3D } from "./Gantt3DChart.js";
+import { Hive3DChart, HiveCurve3D, HiveFrame3D, HivePosition3D } from "./Hive3DChart.js";
+import { Icicle3DChart, IcicleDepth3D, IcicleOrder3D } from "./Icicle3DChart.js";
+import { MatrixCube3D, MatrixCubeFilter3D, MatrixCubeForm3D, MatrixCubeMark3D, MatrixCubeOrder3D, MatrixCubeSizing3D } from "./MatrixCube3D.js";
+import { LayerBridge3D, LayerPlacement3D, LayerStack3D, MultilayerNetwork3D } from "./MultilayerNetwork3D.js";
+import { Parallel3DCoordinates, ParallelCurve3D, ParallelFrame3D, ParallelScale3D } from "./Parallel3DCoordinates.js";
+import { Sankey3DChart, SankeyAlign3D, SankeyLink3D, SankeyOrder3D, SankeyStage3D } from "./Sankey3DChart.js";
+import { Sphere3DGraph, SphereArrangement3D, SphereRoute3D, SphereShell3D } from "./Sphere3DGraph.js";
+import { Spiral3DTimeline, SpiralForm3D, SpiralMark3D } from "./Spiral3DTimeline.js";
+import { Sunburst3DChart, SunburstExtrude3D, SunburstShape3D, SunburstSweep3D } from "./Sunburst3DChart.js";
+import { Timeline3DChart, TimelineMark3D, TimelinePath3D } from "./Timeline3DChart.js";
+import { Tree3DChart, TreeAlignment3D, TreeLink3D, TreeNodeSize3D, TreeSurface3D } from "./Tree3DChart.js";
+import { Treemap3DChart, TreemapOrder3D, TreemapRelief3D, TreemapTile3D } from "./Treemap3DChart.js";
+// src/charts/threenetwork/index.ts
+var threenetworkCatalog = [
+	Force3DGraph,
+	Sphere3DGraph,
+	Hive3DChart,
+	Dag3DChart,
+	Arc3DDiagram,
+	MultilayerNetwork3D,
+	MatrixCube3D,
+	Tree3DChart,
+	ConeTreeChart,
+	Treemap3DChart,
+	CirclePack3DChart,
+	Sunburst3DChart,
+	Icicle3DChart,
+	City3DChart,
+	Sankey3DChart,
+	Chord3DChart,
+	Parallel3DCoordinates,
+	Timeline3DChart,
+	Gantt3DChart,
+	Calendar3DChart,
+	Spiral3DTimeline
+];
+export { Arc3DDiagram, ArcOrder3D, ArcPlane3D, ArcProfile3D, Calendar3DChart, CalendarAggregate3D, CalendarLayout3D, CalendarMark3D, CalendarWeekStart3D, Chord3DChart, ChordArc3D, ChordOrder3D, ChordRim3D, CirclePack3DChart, City3DChart, CityBuilding3D, CityLots3D, CityTerrain3D, ConeAxis3D, ConeLink3D, ConeRadius3D, ConeSpacing3D, ConeTreeChart, DAY, Dag3DChart, DagFlow3D, DagLayer3D, DagRoute3D, Force3DGraph, ForceGraphLayout3D, ForceLayout3D, ForceLinkStyle3D, Gantt3DChart, GanttHeight3D, GanttOrder3D, GanttStack3D, Graph3DBase, Hierarchy3DBase, Hive3DChart, HiveCurve3D, HiveFrame3D, HivePosition3D, Icicle3DChart, IcicleDepth3D, IcicleOrder3D, LabelSpacer3D, LayerBridge3D, LayerPlacement3D, LayerStack3D, Loft, MatrixCube3D, MatrixCubeFilter3D, MatrixCubeForm3D, MatrixCubeMark3D, MatrixCubeOrder3D, MatrixCubeSizing3D, MultilayerNetwork3D, NetworkMarks3D, NodeSizing3D, PackForm3D, PackLift3D, PackParents3D, Parallel3DCoordinates, ParallelCurve3D, ParallelFrame3D, ParallelScale3D, Path3D, RingSegment3D, Sankey3DChart, SankeyAlign3D, SankeyLink3D, SankeyOrder3D, SankeyStage3D, Sphere3DGraph, SphereArrangement3D, SphereRoute3D, SphereShell3D, Spiral3DTimeline, SpiralForm3D, SpiralMark3D, Sunburst3DChart, SunburstExtrude3D, SunburstShape3D, SunburstSweep3D, Temporal3DBase, Timeline3DChart, TimelineMark3D, TimelinePath3D, Tree3DChart, TreeAlignment3D, TreeLink3D, TreeNodeSize3D, TreeSurface3D, Treemap3DChart, TreemapOrder3D, TreemapRelief3D, TreemapTile3D, threenetworkCatalog };

package/dist/charts/threesurfaces/ColorRamp.js

@@ -0,0 +1,18 @@
+import { Color } from "three";
+// src/charts/threesurfaces/ColorRamp.ts
+/** Pre-resolved colour ramp, so painting thousands of vertices does not reparse thousands of colour strings. */
+var ColorRamp = class {
+	lo;
+	hi;
+	table;
+	constructor(fn, lo = 0, hi = 1, size = 128) {
+		this.lo = lo;
+		this.hi = hi;
+		this.table = Array.from({ length: size }, (_, k) => new Color(fn(lo + (hi - lo) * k / (size - 1))));
+	}
+	at(t) {
+		const position = Number.isFinite(t) ? (t - this.lo) / (this.hi - this.lo) : 0;
+		return this.table[Math.round(Math.max(0, Math.min(1, position)) * (this.table.length - 1))];
+	}
+};
+export { ColorRamp };