@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/timeline/TimeMarks.js

@@ -0,0 +1,95 @@
+import { TimeRows } from "./TimeRows.js";
+import { axisBottom, axisLeft } from "d3";
+// src/charts/timeline/TimeMarks.ts
+/** SVG geometry and axis drawing shared by the timeline charts. */
+var TimeMarks = class TimeMarks {
+	/** Rounded bar outline. Paths rather than rects so every bar style animates the same way. */
+	static bar(x, y, width, height, radius = 4) {
+		const w = Math.max(0, width), r = Math.min(radius, w / 2, height / 2);
+		return `M${x + r},${y}H${x + w - r}A${r},${r} 0 0 1 ${x + w},${y + r}V${y + height - r}A${r},${r} 0 0 1 ${x + w - r},${y + height}H${x + r}A${r},${r} 0 0 1 ${x},${y + height - r}V${y + r}A${r},${r} 0 0 1 ${x + r},${y}Z`;
+	}
+	/** Bar ending in an arrow point, for work that flows forward. */
+	static chevron(x, y, width, height) {
+		const w = Math.max(0, width), tip = Math.min(height / 2, w);
+		return `M${x},${y}H${x + w - tip}L${x + w},${y + height / 2}L${x + w - tip},${y + height}H${x}Z`;
+	}
+	/** Open arrowhead ending at `(x, y)` and pointing along `(dx, dy)`, one of the four axis directions. */
+	static arrow(x, y, dx = 1, dy = 0, size = 4) {
+		const px = -dy, py = dx;
+		return `M${x - dx * size + px * size * .75},${y - dy * size + py * size * .75}L${x},${y}L${x - dx * size - px * size * .75},${y - dy * size - py * size * .75}`;
+	}
+	/** Finish-to-start connector: a right-angled route that goes around when the successor starts early. */
+	static connector(x1, y1, x2, y2, turn = 6) {
+		const head = TimeMarks.arrow(x2, y2);
+		if (x2 - x1 >= turn * 2) return `M${x1},${y1}H${x1 + turn}V${y2}H${x2}${head}`;
+		const between = y2 > y1 ? y2 - Math.min(10, Math.abs(y2 - y1) / 2) : y2 + Math.min(10, Math.abs(y2 - y1) / 2);
+		return `M${x1},${y1}H${x1 + turn}V${between}H${x2 - turn}V${y2}H${x2}${head}`;
+	}
+	/** Row labels cut to the gutter and thinned when rows get shorter than the text. */
+	static bandFormat(scale) {
+		const domain = scale.domain();
+		const stride = Math.ceil(13 / Math.max(1, scale.step()));
+		return (value) => domain.indexOf(value) % stride ? "" : TimeRows.fit(String(value), 84);
+	}
+	/** Vertical (or horizontal) grid at time ticks, kept behind the marks. */
+	static grid(ctx, scale, horizontal = true, count) {
+		const { width, height } = ctx.plot;
+		const ticks = scale.ticks(count ?? Math.min(7, Math.floor((horizontal ? width : height) / 80)));
+		const lines = ctx.marks("time-grid", "line", ticks, (tick) => +tick).attr("stroke", ctx.theme.grid).attr("stroke-width", 1);
+		ctx.set(lines, horizontal ? {
+			x1: (d) => scale(d),
+			x2: (d) => scale(d),
+			y1: 0,
+			y2: height
+		} : {
+			x1: 0,
+			x2: width,
+			y1: (d) => scale(d),
+			y2: (d) => scale(d)
+		});
+		ctx.group("time-grid").lower();
+	}
+	/** Time axis for charts that do not extend `CartesianChart`, drawn on the bottom or left edge. */
+	static axis(ctx, scale, side = "bottom") {
+		const { width, height } = ctx.plot, horizontal = side === "bottom";
+		const count = Math.max(2, Math.floor(horizontal ? Math.min(7, width / 80) : height / 44));
+		const axis = (horizontal ? axisBottom(scale) : axisLeft(scale)).ticks(count).tickSizeOuter(0).tickSize(horizontal ? 6 : 0);
+		const group = ctx.group("time-axis").attr("transform", horizontal ? `translate(0,${height})` : null).call(axis);
+		group.select(".domain").attr("stroke", horizontal ? ctx.theme.axis : "none");
+		group.selectAll(".tick line").attr("stroke", ctx.theme.axis);
+		group.selectAll("text").attr("fill", ctx.theme.inkSecondary).attr("font-size", 11).attr("font-family", ctx.theme.fontFamily);
+		TimeMarks.grid(ctx, scale, horizontal, count);
+	}
+	/** Stepped sequential key: `Less ▢▢▢▢▢ More`, right aligned at `(right, y)`. */
+	static ramp(ctx, right, y, low = "Less", high = "More") {
+		const steps = [
+			.08,
+			.3,
+			.52,
+			.76,
+			1
+		], size = 9;
+		const left = right - steps.length * 11 - TimeMarks.textWidth(high) - 4;
+		const cells = ctx.marks("ramp", "rect", steps).attr("fill", (d) => ctx.palette.sequential(d)).attr("rx", 2);
+		ctx.set(cells, {
+			x: (_, i) => left + i * 11,
+			y: y - size,
+			width: size,
+			height: size
+		});
+		const names = [{
+			text: low,
+			x: left - 4,
+			anchor: "end"
+		}, {
+			text: high,
+			x: right,
+			anchor: "end"
+		}];
+		ctx.text(ctx.marks("ramp-label", "text", names, (d) => d.text).attr("x", (d) => d.x).attr("y", y).attr("text-anchor", (d) => d.anchor).text((d) => d.text), 10, "muted");
+	}
+	static textWidth(text) {
+		return text.length * 5.7;
+	}
+};
+export { TimeMarks };

package/dist/charts/timeline/TimeRows.js

@@ -0,0 +1,128 @@
+import { utcFormat } from "d3";
+// src/charts/timeline/TimeRows.ts
+var LONG = utcFormat("%b %-d, %Y");
+var SHORT = utcFormat("%b %-d");
+/** Parsing and packing shared by the timeline charts. Everything tolerates missing and malformed cells. */
+var TimeRows = class {
+	static DAY = 864e5;
+	static date(cell) {
+		if (cell === null || cell === void 0 || cell === "") return null;
+		const date = cell instanceof Date ? cell : new Date(cell);
+		return Number.isNaN(+date) ? null : date;
+	}
+	static number(cell) {
+		if (cell === null || cell === void 0 || cell === "") return null;
+		const value = +cell;
+		return Number.isFinite(value) ? value : null;
+	}
+	static text(cell, fallback = "—") {
+		return cell === null || cell === void 0 || cell === "" ? fallback : String(cell);
+	}
+	static long(date) {
+		return LONG(date);
+	}
+	static short(date) {
+		return SHORT(date);
+	}
+	static days(from, to) {
+		return (+to - +from) / this.DAY;
+	}
+	static addDays(date, days) {
+		return new Date(+date + days * this.DAY);
+	}
+	static floorDay(date) {
+		return new Date(Math.floor(+date / this.DAY) * this.DAY);
+	}
+	/** Signed day count such as `+3d`, without trailing noise. */
+	static signedDays(days) {
+		const rounded = Math.round(days * 10) / 10;
+		return `${rounded > 0 ? "+" : ""}${rounded}d`;
+	}
+	/** Rows with a usable start. A missing end makes an instant, and reversed dates are swapped. */
+	static spans(rows, { label, start, end, group }) {
+		return rows.flatMap((row, index) => {
+			const from = this.date(row[start]), to = this.date(row[end]) ?? from;
+			if (!from || !to) return [];
+			return [{
+				row,
+				index,
+				label: this.text(row[label], `#${index + 1}`),
+				group: this.text(row[group], "Other"),
+				start: from <= to ? from : to,
+				end: from <= to ? to : from
+			}];
+		});
+	}
+	/** Never empty and never zero-width, so scales stay finite for empty or single-row data. */
+	static extent(dates) {
+		if (!dates.length) {
+			const now = this.floorDay(/* @__PURE__ */ new Date());
+			return [now, this.addDays(now, 7)];
+		}
+		const stamps = dates.map(Number), low = Math.min(...stamps), high = Math.max(...stamps);
+		return low === high ? [new Date(low - this.DAY), new Date(high + this.DAY)] : [new Date(low), new Date(high)];
+	}
+	/** First-fit interval packing: each span gets the lowest lane free at its start. */
+	static pack(spans, gap = 0) {
+		const ends = [], lanes = /* @__PURE__ */ new Map();
+		for (const span of [...spans].sort((a, b) => +a.start - +b.start)) {
+			let lane = ends.findIndex((end) => end + gap <= +span.start);
+			if (lane < 0) lane = ends.length;
+			ends[lane] = +span.end;
+			lanes.set(span, lane);
+		}
+		return lanes;
+	}
+	/** Band keys must be unique: repeats get invisible zero-width suffixes. */
+	static unique(labels) {
+		const seen = /* @__PURE__ */ new Set();
+		return labels.map((label) => {
+			let key = label;
+			while (seen.has(key)) key += "​";
+			seen.add(key);
+			return key;
+		});
+	}
+	/** Cuts text to fit `room` pixels using the library's character width estimate. */
+	static fit(text, room, size = 11) {
+		const chars = Math.floor(room / (size * .564));
+		if (text.length <= chars) return text;
+		return chars < 3 ? "" : `${text.slice(0, chars - 1)}…`;
+	}
+	static width(text, size = 11) {
+		return text.length * size * .564;
+	}
+	/** Long rows to one record per date, summing duplicates. Series keep first-seen order. */
+	static pivot(rows, date, series, value) {
+		const names = /* @__PURE__ */ new Map(), byDate = /* @__PURE__ */ new Map();
+		for (const row of rows) {
+			const when = this.date(row[date]), name = this.text(row[series], "Other");
+			if (!when) continue;
+			names.set(name, true);
+			const record = byDate.get(+when) ?? { date: +when };
+			record[name] = (record[name] ?? 0) + Math.max(0, this.number(row[value]) ?? 0);
+			byDate.set(+when, record);
+		}
+		const keys = [...names.keys()];
+		const table = [...byDate.values()].sort((a, b) => a.date - b.date);
+		for (const record of table) for (const key of keys) record[key] ??= 0;
+		return {
+			names: keys,
+			table
+		};
+	}
+	/** Least-squares line through `[x, y]` pairs; null when there are fewer than two distinct x. */
+	static trend(points) {
+		const n = points.length;
+		if (n < 2) return null;
+		const mx = points.reduce((sum, p) => sum + p[0], 0) / n, my = points.reduce((sum, p) => sum + p[1], 0) / n;
+		const spread = points.reduce((sum, p) => sum + (p[0] - mx) ** 2, 0);
+		if (!spread) return null;
+		const slope = points.reduce((sum, p) => sum + (p[0] - mx) * (p[1] - my), 0) / spread;
+		return {
+			slope,
+			intercept: my - slope * mx
+		};
+	}
+};
+export { TimeRows };

package/dist/charts/timeline/TimeSamples.js

@@ -0,0 +1,96 @@
+import { SampleData } from "../../data/SampleData.js";
+import { TimeRows } from "./TimeRows.js";
+// src/charts/timeline/TimeSamples.ts
+var STATES = [
+	"Backlog",
+	"In progress",
+	"Review",
+	"Done"
+];
+/** Reshapes `SampleData` into the forms project and delivery charts read. */
+var TimeSamples = class {
+	/** `SampleData.tasks` plus `dependsOn`: each task follows the previous task in its group, and some join two. Listed by group, like a work breakdown. */
+	static plan(seed, count = 14) {
+		return SampleData.tasks(seed, count).map((row, i, rows) => {
+			const before = [i >= 4 ? rows[i - 4].task : null, i >= 3 && i % 3 === 0 ? rows[i - 3].task : null].filter(Boolean);
+			return {
+				...row,
+				dependsOn: before.join(", ")
+			};
+		}).sort((a, b) => String(a.group).localeCompare(String(b.group)));
+	}
+	/** A sprint in flight: `{ date, remaining, done, scope }`, with null actuals for days still to come. */
+	static sprint(seed, days = 42, elapsed = .68) {
+		const walk = SampleData.timeSeries(seed, days, 1);
+		let scope = 240, done = 0;
+		return walk.map((row, i) => {
+			const step = Math.abs(+row.value - +(walk[i - 1]?.value ?? row.value));
+			done = Math.min(scope, done + 3 + step * 2.2);
+			if (i && i % 13 === 0) scope += 14 + Math.round(step * 3);
+			const live = i <= days * elapsed;
+			return {
+				date: row.date,
+				remaining: live ? +(scope - done).toFixed(1) : null,
+				done: live ? +done.toFixed(1) : null,
+				scope
+			};
+		});
+	}
+	/** Long-form `{ date, state, value }` counts per workflow state, cumulative from arrivals through to done. */
+	static flow(seed, days = 60) {
+		const walk = SampleData.timeSeries(seed, days, 4);
+		const through = STATES.map(() => 0);
+		return Array.from({ length: days }, (_, d) => {
+			STATES.forEach((_, s) => {
+				const rate = 4.2 - s * .55 + +walk[s * days + d].value % 3 * .6;
+				through[s] = Math.min(s ? through[s - 1] : Infinity, through[s] + rate);
+			});
+			return STATES.map((state, s) => ({
+				date: walk[d].date,
+				state,
+				value: +(through[s] - (through[s + 1] ?? 0)).toFixed(1)
+			}));
+		}).flat();
+	}
+	/** Hourly `{ date, value }` with a daily and weekly rhythm laid over the seeded walk. */
+	static hourly(seed, days = 180) {
+		const start = +new Date(Date.UTC(2026, 0, 1));
+		return SampleData.timeSeries(seed, days * 24, 1).map((row, i) => {
+			const date = new Date(start + i * 36e5), hour = date.getUTCHours(), weekday = date.getUTCDay();
+			const rhythm = 1 + .8 * Math.max(0, Math.sin((hour - 6) / 12 * Math.PI)) - (weekday % 6 === 0 ? .5 : 0);
+			return {
+				date,
+				value: +(+row.value * rhythm).toFixed(1)
+			};
+		});
+	}
+	/** One row per subject and state change: `{ subject, date, state }`. */
+	static journeys(seed, count = 12) {
+		return SampleData.tasks(seed, count).flatMap((row) => {
+			const start = row.start, end = row.end, length = TimeRows.days(start, end);
+			return [
+				{
+					subject: row.task,
+					date: start,
+					state: "Intake"
+				},
+				{
+					subject: row.task,
+					date: TimeRows.addDays(start, length * (.2 + .3 * +row.progress)),
+					state: "Treatment"
+				},
+				{
+					subject: row.task,
+					date: TimeRows.addDays(start, length * (.65 + .2 * +row.progress)),
+					state: "Follow-up"
+				},
+				{
+					subject: row.task,
+					date: end,
+					state: "Closed"
+				}
+			];
+		});
+	}
+};
+export { TimeSamples };

package/dist/charts/timeline/TimelineChart.js

@@ -0,0 +1,221 @@
+import { Chart2D } from "../../core/Chart2D.js";
+import { ChartFamily, DataShape, Dimension, Orientation, SymbolKind } from "../../core/enums.js";
+import { Scales } from "../../core/Scales.js";
+import { SampleData } from "../../data/SampleData.js";
+import { TimeMarks } from "./TimeMarks.js";
+import { TimeRows } from "./TimeRows.js";
+import { scaleUtc, symbol } from "d3";
+// src/charts/timeline/TimelineChart.ts
+var TimelineLayout = /* @__PURE__ */ function(TimelineLayout) {
+	TimelineLayout["Alternate"] = "alternate";
+	TimelineLayout["OneSided"] = "one-sided";
+	TimelineLayout["Grouped"] = "grouped";
+	return TimelineLayout;
+}({});
+var TimelineSpacing = /* @__PURE__ */ function(TimelineSpacing) {
+	TimelineSpacing["Proportional"] = "proportional";
+	TimelineSpacing["Even"] = "even";
+	return TimelineSpacing;
+}({});
+var TimelineStem = /* @__PURE__ */ function(TimelineStem) {
+	TimelineStem["Straight"] = "straight";
+	TimelineStem["Elbow"] = "elbow";
+	return TimelineStem;
+}({});
+var LINE = 28;
+var FIRST = 16;
+var ELBOW = 12;
+/** Tell a sequence of dated events along one axis, with leader lines to their labels. */
+var TimelineChart = class extends Chart2D {
+	static meta = {
+		id: "timeline",
+		name: "Timeline",
+		family: ChartFamily.Temporal,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Places dated events along a single axis with leader-line labels, for histories and release narratives.",
+		tags: [
+			"events",
+			"history",
+			"chronology"
+		],
+		sample: (seed) => SampleData.tasks(seed, 10).map((row) => ({
+			date: row.start,
+			label: row.task,
+			group: row.group
+		})),
+		variants: {
+			orientation: [Orientation.Horizontal, Orientation.Vertical],
+			layout: Object.values(TimelineLayout),
+			spacing: Object.values(TimelineSpacing),
+			symbol: [
+				SymbolKind.Circle,
+				SymbolKind.Diamond,
+				SymbolKind.Square
+			],
+			stem: Object.values(TimelineStem)
+		}
+	};
+	defaults() {
+		return {
+			date: "date",
+			label: "label",
+			group: "group",
+			orientation: Orientation.Horizontal,
+			layout: "alternate",
+			spacing: "proportional",
+			symbol: SymbolKind.Circle,
+			stem: "straight"
+		};
+	}
+	get horizontal() {
+		return this.options.orientation === Orientation.Horizontal;
+	}
+	get timeAxis() {
+		return this.options.spacing === "proportional";
+	}
+	plotMargin() {
+		const axis = this.timeAxis;
+		return this.horizontal ? {
+			top: 8,
+			right: 16,
+			bottom: axis ? 26 : 10,
+			left: 16
+		} : {
+			top: 10,
+			right: 16,
+			bottom: 12,
+			left: axis ? 58 : 16
+		};
+	}
+	lanes(along, cross, names) {
+		const { layout } = this.options, horizontal = this.horizontal;
+		if (layout === "alternate") return [{
+			at: cross / 2,
+			room: cross / 2,
+			sides: [-1, 1],
+			group: null
+		}];
+		if (layout === "one-sided") return [{
+			at: horizontal ? cross - 10 : 10,
+			room: cross - 10,
+			sides: [horizontal ? -1 : 1],
+			group: null
+		}];
+		const size = cross / Math.max(1, names.length);
+		return names.map((group, i) => ({
+			at: horizontal ? size * (i + 1) - 8 : size * i + 8,
+			room: size - 8,
+			sides: [horizontal ? -1 : 1],
+			group
+		}));
+	}
+	draw(ctx) {
+		const { data, date, label, group, symbol: kind, stem } = this.options;
+		const { width, height } = ctx.plot, horizontal = this.horizontal;
+		const along = horizontal ? width : height, cross = horizontal ? height : width;
+		const raw = data.flatMap((row, i) => {
+			const when = TimeRows.date(row[date]);
+			return when ? [{
+				when,
+				label: TimeRows.text(row[label], `#${i + 1}`),
+				group: TimeRows.text(row[group], "Other")
+			}] : [];
+		}).sort((a, b) => +a.when - +b.when);
+		const scale = scaleUtc(TimeRows.extent(raw.map((d) => d.when)), [8, along - 8]).nice();
+		if (this.timeAxis) TimeMarks.axis(ctx, scale, horizontal ? "bottom" : "left");
+		else for (const name of ["time-axis", "time-grid"]) ctx.group(name).selectAll("*").remove();
+		const names = [...new Set(raw.map((d) => d.group))];
+		const lanes = this.lanes(along, cross, names);
+		const step = raw.length > 1 ? (along - 16) / (raw.length - 1) : 0;
+		const bend = stem === "elbow" ? ELBOW : 0;
+		const labelRoom = horizontal ? Math.min(120, along / 3) : Math.min(120, cross / 2.4);
+		const levels = (lane) => Math.max(1, Math.floor((lane.room - FIRST + (horizontal ? 4 : 8)) / (horizontal ? 32 : labelRoom + 8)));
+		const taken = /* @__PURE__ */ new Map();
+		const events = raw.map((d, i) => {
+			const at = this.timeAxis ? scale(d.when) : 8 + i * step;
+			const laneIndex = lanes.findIndex((lane) => lane.group === d.group || lane.group === null);
+			const lane = lanes[laneIndex];
+			const name = TimeRows.fit(d.label, labelRoom);
+			const size = horizontal ? Math.max(TimeRows.width(name), TimeRows.width(TimeRows.short(d.when), 10)) + 8 + bend : 30;
+			const flip = horizontal && at + size > along;
+			const start = horizontal ? flip ? at - size : at : Math.max(0, Math.min(along - size, at - size / 2));
+			const sides = lane.sides.length > 1 && i % 2 ? [...lane.sides].reverse() : lane.sides;
+			for (let level = 0; level < levels(lane); level++) for (const side of sides) {
+				const key = `${laneIndex}/${side}/${level}`;
+				if ((taken.get(key) ?? -Infinity) > start) continue;
+				taken.set(key, start + size);
+				return {
+					label: d.label,
+					group: d.group,
+					date: d.when,
+					at,
+					lane: laneIndex,
+					side,
+					level,
+					start,
+					flip,
+					labelled: true
+				};
+			}
+			return {
+				label: d.label,
+				group: d.group,
+				date: d.when,
+				at,
+				lane: laneIndex,
+				side: sides[0],
+				level: 0,
+				start,
+				flip,
+				labelled: false
+			};
+		});
+		const map = (a, c) => horizontal ? `${a},${c}` : `${c},${a}`;
+		const reach = (d) => horizontal ? FIRST + d.level * 32 + LINE : FIRST + d.level * (labelRoom + 8);
+		const axisAt = (d) => lanes[d.lane].at;
+		const shift = (d) => d.flip ? -bend : bend;
+		const rails = ctx.marks("rails", "path", lanes, (lane) => lane.group ?? "all").attr("fill", "none").attr("stroke", ctx.theme.axis).attr("stroke-width", 2);
+		ctx.set(rails, { d: (lane) => `M${map(0, lane.at)}L${map(along, lane.at)}` });
+		const stems = ctx.marks("stems", "path", events.filter((d) => d.labelled), (d) => `${d.label}/${+d.date}`).attr("fill", "none").attr("stroke", ctx.theme.axis).attr("stroke-width", 1);
+		ctx.set(stems, { d: (d) => {
+			const base = axisAt(d), end = base + d.side * reach(d);
+			if (!bend) return `M${map(d.at, base)}L${map(d.at, end)}`;
+			const knee = base + d.side * Math.min(8, reach(d) / 3);
+			return `M${map(d.at, base)}L${map(d.at, knee)}L${map(d.at + shift(d), knee + d.side * 6)}L${map(d.at + shift(d), end)}`;
+		} });
+		const dots = ctx.marks("dots", "path", events, (d) => `${d.label}/${+d.date}`).attr("fill", (d) => ctx.palette.color(d.group)).attr("stroke", ctx.theme.surface).attr("stroke-width", 2);
+		ctx.set(dots, {
+			d: symbol(Scales.symbol(kind), 90)(),
+			transform: (d) => horizontal ? `translate(${d.at},${axisAt(d)})` : `translate(${axisAt(d)},${d.at})`
+		}, {}, 20);
+		ctx.hover(dots, (d) => ({
+			title: d.label,
+			color: ctx.palette.color(d.group),
+			rows: [["Date", TimeRows.long(d.date)], ["Group", d.group]]
+		}));
+		const placed = events.filter((d) => d.labelled);
+		const anchor = (d) => {
+			if (horizontal) return {
+				x: d.at + shift(d) + (d.flip ? -5 : 5),
+				y: d.side < 0 ? axisAt(d) - reach(d) + 10 : axisAt(d) + reach(d) - 18
+			};
+			return {
+				x: axisAt(d) + d.side * (reach(d) + 5),
+				y: d.start + 11
+			};
+		};
+		const textAnchor = (d) => d.flip || !horizontal && d.side < 0 ? "end" : "start";
+		const titles = ctx.marks("titles", "text", placed, (d) => `${d.label}/${+d.date}`).attr("text-anchor", textAnchor).attr("font-weight", 600).text((d) => TimeRows.fit(d.label, labelRoom));
+		ctx.text(ctx.set(titles, {
+			x: (d) => anchor(d).x,
+			y: (d) => anchor(d).y
+		}), 11, "ink");
+		const dates = ctx.marks("dates", "text", placed, (d) => `${d.label}/${+d.date}`).attr("text-anchor", textAnchor).text((d) => TimeRows.short(d.date));
+		ctx.text(ctx.set(dates, {
+			x: (d) => anchor(d).x,
+			y: (d) => anchor(d).y + 13
+		}), 10, "muted");
+	}
+};
+export { TimelineChart, TimelineLayout, TimelineSpacing, TimelineStem };

package/dist/charts/timeline/index.js

@@ -0,0 +1,54 @@
+import { TimeRows } from "./TimeRows.js";
+import { TimeBandChart } from "./TimeBandChart.js";
+import { GanttBar, GanttChart, GanttProgress, GanttShade, GanttSort } from "./GanttChart.js";
+import { TimelineChart, TimelineLayout, TimelineSpacing, TimelineStem } from "./TimelineChart.js";
+import { SwimlaneChart, SwimlaneMark, SwimlaneOrder, SwimlaneOverlap, SwimlaneSizing } from "./SwimlaneChart.js";
+import { CalendarAggregate, CalendarHeatCell, CalendarHeatmap, CalendarLayout, CalendarWeekStart } from "./CalendarHeatmap.js";
+import { MilestoneChart, MilestoneConnector, MilestoneFrame, MilestoneSort } from "./MilestoneChart.js";
+import { EventDropArrangement, EventDropChart, EventDropDensity, EventDropMark, EventDropOrder } from "./EventDropChart.js";
+import { CriticalPathMethod } from "./CriticalPathMethod.js";
+import { PERTChart, PertLayout, PertLink, PertNode } from "./PERTChart.js";
+import { BurnChart, BurnForecast, BurnMark } from "./BurnChart.js";
+import { BurndownChart, BurndownIdeal } from "./BurndownChart.js";
+import { BurnupChart, BurnupScope, BurnupUnit } from "./BurnupChart.js";
+import { CumulativeFlowChart, FlowOffset, FlowScope, FlowStacking } from "./CumulativeFlowChart.js";
+import { RoadmapChart, RoadmapGrouping, RoadmapLabel, RoadmapMark, RoadmapSnap } from "./RoadmapChart.js";
+import { StreamTimeline, StreamTimelineBin, StreamTimelineCurve, StreamTimelineOffset, StreamTimelineOrder } from "./StreamTimeline.js";
+import { MarimekkoTime, MekkoForm, MekkoOrder, MekkoPeriod } from "./MarimekkoTime.js";
+import { PeriodicCell, PeriodicCycle, PeriodicForm, PeriodicHeatmap, PeriodicScaling } from "./PeriodicHeatmap.js";
+import { ChronologyChart, ChronologyLabel, ChronologyMark, ChronologyPacking, ChronologyScale } from "./ChronologyChart.js";
+import { CriticalLinks, CriticalPathChart, CriticalSchedule, CriticalSlack, CriticalSort } from "./CriticalPathChart.js";
+import { ResourceAllocationChart, ResourceBin, ResourceForm, ResourceSort } from "./ResourceAllocationChart.js";
+import { LifelineAlign, LifelineChart, LifelineEvents, LifelineSort, LifelineTrack } from "./LifelineChart.js";
+import { MilestoneTrendChart, MilestoneTrendFrame } from "./MilestoneTrendChart.js";
+import { CycleGuides, CycleTimeChart } from "./CycleTimeChart.js";
+import { SpiralDirection, SpiralMark, SpiralPeriod, SpiralTimeline } from "./SpiralTimeline.js";
+import { CalendarSkylineChart, SkylineShape } from "./CalendarSkylineChart.js";
+import { ScheduleBlockBase, ScheduleBlockHeight, ScheduleBlockOrder, ScheduleBlocksChart } from "./ScheduleBlocksChart.js";
+// src/charts/timeline/index.ts
+var timelineCatalog = [
+	GanttChart,
+	TimelineChart,
+	SwimlaneChart,
+	CalendarHeatmap,
+	MilestoneChart,
+	EventDropChart,
+	PERTChart,
+	BurndownChart,
+	BurnupChart,
+	CumulativeFlowChart,
+	RoadmapChart,
+	StreamTimeline,
+	MarimekkoTime,
+	PeriodicHeatmap,
+	ChronologyChart,
+	CriticalPathChart,
+	ResourceAllocationChart,
+	LifelineChart,
+	MilestoneTrendChart,
+	CycleTimeChart,
+	SpiralTimeline,
+	CalendarSkylineChart,
+	ScheduleBlocksChart
+];
+export { BurnChart, BurnForecast, BurnMark, BurndownChart, BurndownIdeal, BurnupChart, BurnupScope, BurnupUnit, CalendarAggregate, CalendarHeatCell, CalendarHeatmap, CalendarLayout, CalendarSkylineChart, CalendarWeekStart, ChronologyChart, ChronologyLabel, ChronologyMark, ChronologyPacking, ChronologyScale, CriticalLinks, CriticalPathChart, CriticalPathMethod, CriticalSchedule, CriticalSlack, CriticalSort, CumulativeFlowChart, CycleGuides, CycleTimeChart, EventDropArrangement, EventDropChart, EventDropDensity, EventDropMark, EventDropOrder, FlowOffset, FlowScope, FlowStacking, GanttBar, GanttChart, GanttProgress, GanttShade, GanttSort, LifelineAlign, LifelineChart, LifelineEvents, LifelineSort, LifelineTrack, MarimekkoTime, MekkoForm, MekkoOrder, MekkoPeriod, MilestoneChart, MilestoneConnector, MilestoneFrame, MilestoneSort, MilestoneTrendChart, MilestoneTrendFrame, PERTChart, PeriodicCell, PeriodicCycle, PeriodicForm, PeriodicHeatmap, PeriodicScaling, PertLayout, PertLink, PertNode, ResourceAllocationChart, ResourceBin, ResourceForm, ResourceSort, RoadmapChart, RoadmapGrouping, RoadmapLabel, RoadmapMark, RoadmapSnap, ScheduleBlockBase, ScheduleBlockHeight, ScheduleBlockOrder, ScheduleBlocksChart, SkylineShape, SpiralDirection, SpiralMark, SpiralPeriod, SpiralTimeline, StreamTimeline, StreamTimelineBin, StreamTimelineCurve, StreamTimelineOffset, StreamTimelineOrder, SwimlaneChart, SwimlaneMark, SwimlaneOrder, SwimlaneOverlap, SwimlaneSizing, TimeBandChart, TimeRows, TimelineChart, TimelineLayout, TimelineSpacing, TimelineStem, timelineCatalog };