@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/timeline/CalendarSkylineChart.js

@@ -0,0 +1,128 @@
+import { Chart3D } from "../../core/Chart3D.js";
+import { ChartFamily, DataShape, Dimension, ScaleKind } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { CalendarWeekStart } from "./CalendarHeatmap.js";
+import { TimeRows } from "./TimeRows.js";
+import { rollup, scaleLinear, scalePow, sum, utcDay, utcMonday, utcSunday } from "d3";
+import { BoxGeometry, CylinderGeometry, InstancedMesh, Mesh, MeshStandardMaterial, Object3D, PlaneGeometry } from "three";
+// src/charts/timeline/CalendarSkylineChart.ts
+var SkylineShape = /* @__PURE__ */ function(SkylineShape) {
+	SkylineShape["Block"] = "blocks";
+	SkylineShape["Column"] = "columns";
+	return SkylineShape;
+}({});
+var BASE = -.7;
+var MONTH_NAMES = [
+	"Jan",
+	"Feb",
+	"Mar",
+	"Apr",
+	"May",
+	"Jun",
+	"Jul",
+	"Aug",
+	"Sep",
+	"Oct",
+	"Nov",
+	"Dec"
+];
+/** A year of daily activity as a city: weeks run along the floor and each day rises by its value. */
+var CalendarSkylineChart = class extends Chart3D {
+	static meta = {
+		id: "calendar-skyline",
+		name: "Calendar skyline",
+		family: ChartFamily.Temporal,
+		dimension: Dimension.Three,
+		shape: DataShape.Table,
+		description: "Raises a calendar grid into 3D so that peak days stand out as towers above the year.",
+		tags: [
+			"contribution",
+			"daily",
+			"skyline",
+			"city"
+		],
+		sample: (seed) => SampleData.timeSeries(seed, 280, 1).map((row, i, rows) => ({
+			date: row.date,
+			value: +(.5 + Math.min(3, Math.abs(+row.value - +(rows[i - 1]?.value ?? row.value))) * (row.date.getUTCDay() % 6 ? 2 : .6)).toFixed(1)
+		})),
+		variants: {
+			shape: Object.values(SkylineShape),
+			weekStart: Object.values(CalendarWeekStart),
+			scale: [ScaleKind.Linear, ScaleKind.Sqrt]
+		}
+	};
+	defaults() {
+		return {
+			date: "date",
+			value: "value",
+			shape: "blocks",
+			weekStart: CalendarWeekStart.Monday,
+			scale: ScaleKind.Linear,
+			distance: 3.7,
+			elevation: 40,
+			azimuth: 24
+		};
+	}
+	build(ctx) {
+		const { data, date, value, shape, weekStart, scale } = this.options;
+		const rows = data.flatMap((row) => {
+			const when = TimeRows.date(row[date]);
+			return when ? [{
+				day: +TimeRows.floorDay(when),
+				value: Math.max(0, TimeRows.number(row[value]) ?? 0)
+			}] : [];
+		});
+		const totals = rollup(rows, (list) => sum(list, (d) => d.value), (d) => d.day);
+		const floor = new Mesh(new PlaneGeometry(2.2, 1.1), new MeshStandardMaterial({ color: ctx.theme.grid }));
+		floor.rotation.x = -Math.PI / 2;
+		floor.position.y = BASE;
+		floor.receiveShadow = true;
+		ctx.root.add(floor);
+		if (!totals.size) return;
+		const stamps = [...totals.keys()], first = new Date(Math.min(...stamps)), last = new Date(Math.max(...stamps));
+		const days = utcDay.range(first, utcDay.offset(last, 1));
+		const week = weekStart === CalendarWeekStart.Monday ? utcMonday : utcSunday;
+		const origin = week.floor(first), weeks = week.count(origin, last) + 1;
+		const cell = Math.min(2 / weeks, 1 / 7), gap = cell * .86;
+		const top = Math.max(1e-9, ...totals.values());
+		const height = scale === ScaleKind.Sqrt ? scalePow().exponent(.5).domain([0, top]).range([0, .7]) : scaleLinear([0, top], [0, .7]);
+		const geometry = shape === "blocks" ? new BoxGeometry(gap, 1, gap) : new CylinderGeometry(gap / 2, gap / 2, 1, 12);
+		const towers = new InstancedMesh(geometry, new MeshStandardMaterial({ roughness: .5 }), days.length);
+		towers.castShadow = towers.receiveShadow = true;
+		const weekday = (day) => weekStart === CalendarWeekStart.Monday ? (day.getUTCDay() + 6) % 7 : day.getUTCDay();
+		const dummy = new Object3D();
+		const place = (progress) => {
+			days.forEach((day, i) => {
+				const h = Math.max(.006, height(totals.get(+day) ?? 0) * progress);
+				dummy.position.set((week.count(origin, day) - weeks / 2 + .5) * cell, BASE + h / 2, (weekday(day) - 3) * cell);
+				dummy.scale.set(1, h, 1);
+				dummy.updateMatrix();
+				towers.setMatrixAt(i, dummy.matrix);
+			});
+			towers.instanceMatrix.needsUpdate = true;
+		};
+		days.forEach((day, i) => {
+			const amount = totals.get(+day);
+			towers.setColorAt(i, ctx.color(amount === void 0 ? ctx.theme.grid : ctx.palette.sequential(.15 + .85 * (amount / top))));
+		});
+		ctx.reveal(place);
+		ctx.root.add(towers);
+		ctx.pick(towers, (i) => ({
+			title: TimeRows.long(days[i]),
+			rows: [["Value", +(totals.get(+days[i]) ?? 0).toFixed(1)]]
+		}));
+		let previous = -1, labelled = -Infinity;
+		for (const day of days) {
+			const month = day.getUTCMonth(), at = week.count(origin, day);
+			if (month === previous || (at - labelled) * cell < .26) continue;
+			previous = month;
+			labelled = at;
+			ctx.label(MONTH_NAMES[month], [
+				(at - weeks / 2 + .5) * cell,
+				BASE,
+				.6
+			], "secondary", 10);
+		}
+	}
+};
+export { CalendarSkylineChart, SkylineShape };

package/dist/charts/timeline/ChronologyChart.js

@@ -0,0 +1,203 @@
+import { Chart2D } from "../../core/Chart2D.js";
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { TimeMarks } from "./TimeMarks.js";
+import { TimeRows } from "./TimeRows.js";
+import { groups, max, scaleUtc } from "d3";
+// src/charts/timeline/ChronologyChart.ts
+var ChronologyPacking = /* @__PURE__ */ function(ChronologyPacking) {
+	ChronologyPacking["FirstFit"] = "packed";
+	ChronologyPacking["OneRowEach"] = "one-row-each";
+	return ChronologyPacking;
+}({});
+var ChronologyMark = /* @__PURE__ */ function(ChronologyMark) {
+	ChronologyMark["Bar"] = "bar";
+	ChronologyMark["Line"] = "capped-line";
+	return ChronologyMark;
+}({});
+var ChronologyLabel = /* @__PURE__ */ function(ChronologyLabel) {
+	ChronologyLabel["Beside"] = "label-beside";
+	ChronologyLabel["Inside"] = "label-inside";
+	ChronologyLabel["Hidden"] = "no-labels";
+	return ChronologyLabel;
+}({});
+var ChronologyScale = /* @__PURE__ */ function(ChronologyScale) {
+	ChronologyScale["Linear"] = "linear-time";
+	ChronologyScale["Compressed"] = "compressed-past";
+	return ChronologyScale;
+}({});
+var RIBBON = 14;
+var POWER = .55;
+var LABEL_ROOM = 42;
+/** Set lives, reigns or periods side by side to see who overlapped whom, in the manner of Priestley's chart of biography. */
+var ChronologyChart = class extends Chart2D {
+	static meta = {
+		id: "chronology",
+		name: "Chronology chart",
+		family: ChartFamily.Temporal,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Packs named periods onto rows beneath era ribbons to show which lives, reigns or phases overlapped.",
+		tags: [
+			"history",
+			"periods",
+			"eras",
+			"biography"
+		],
+		sample: (seed) => SampleData.tasks(seed, 16).map((row) => ({
+			name: row.task,
+			start: row.start,
+			end: TimeRows.addDays(row.end, 6),
+			era: row.group
+		})),
+		variants: {
+			packing: Object.values(ChronologyPacking),
+			mark: Object.values(ChronologyMark),
+			labelStyle: Object.values(ChronologyLabel),
+			scale: Object.values(ChronologyScale),
+			eras: [true, false]
+		},
+		valid: ({ mark, labelStyle }) => mark === "bar" || labelStyle !== "label-inside"
+	};
+	defaults() {
+		return {
+			name: "name",
+			start: "start",
+			end: "end",
+			era: "era",
+			packing: "packed",
+			mark: "bar",
+			labelStyle: "label-beside",
+			scale: "linear-time",
+			eras: true
+		};
+	}
+	plotMargin() {
+		return {
+			top: 8,
+			right: 26,
+			bottom: 26,
+			left: 26
+		};
+	}
+	rows(spans, slack) {
+		if (this.options.packing === "packed") return TimeRows.pack(spans, slack);
+		return new Map([...spans].sort((a, b) => +a.start - +b.start).map((span, i) => [span, i]));
+	}
+	draw(ctx) {
+		const { data, name, start, end, era, mark, labelStyle, scale: scaling, eras } = this.options;
+		const { width, height } = ctx.plot;
+		const spans = TimeRows.spans(data, {
+			label: name,
+			start,
+			end,
+			group: era
+		});
+		for (const span of spans) ctx.palette.color(span.group);
+		const [low, high] = TimeRows.extent(spans.flatMap((span) => [span.start, span.end]));
+		const linear = scaleUtc([low, high], [0, width]).nice();
+		const [from, to] = linear.domain();
+		const age = (date) => (+to - +date) / (+to - +from);
+		const place = (date) => scaling === "compressed-past" ? width * (1 - Math.max(0, age(date)) ** (1 / POWER)) : linear(date);
+		const ticks = linear.ticks(Math.floor(width / 70)).map((tick) => ({
+			tick,
+			x: place(tick),
+			label: linear.tickFormat()(tick)
+		}));
+		const tag = (at) => Math.max(18, Math.min(width - 18, at));
+		let last = -Infinity;
+		const clear = ticks.filter((d) => {
+			if (tag(d.x) - last < 48) return false;
+			last = tag(d.x);
+			return true;
+		});
+		const grid = ctx.marks("grid", "line", clear, (d) => +d.tick).attr("stroke", ctx.theme.grid);
+		ctx.set(grid, {
+			x1: (d) => d.x,
+			x2: (d) => d.x,
+			y1: 0,
+			y2: height
+		});
+		const stamps = ctx.marks("ticks", "text", clear, (d) => +d.tick).attr("text-anchor", "middle").text((d) => d.label);
+		ctx.text(ctx.set(stamps, {
+			x: (d) => tag(d.x),
+			y: height + 16
+		}));
+		const base = ctx.marks("base", "line", [0]).attr("stroke", ctx.theme.axis);
+		ctx.set(base, {
+			x1: 0,
+			x2: width,
+			y1: height,
+			y2: height
+		});
+		const ribbons = eras ? groups(spans, (span) => span.group).map(([group, members]) => {
+			const [a, b] = TimeRows.extent(members.flatMap((span) => [span.start, span.end]));
+			return {
+				group,
+				start: a,
+				end: b
+			};
+		}) : [];
+		const bands = TimeRows.pack(ribbons);
+		const ribbonRows = ribbons.length ? max([...bands.values()]) + 1 : 0;
+		const header = ribbonRows * 16 + (ribbonRows ? 4 : 0);
+		const strips = ctx.marks("eras", "path", ribbons, (d) => d.group).attr("fill", (d) => ctx.palette.color(d.group)).attr("fill-opacity", .22);
+		const stripBox = (d) => ({
+			x: place(d.start),
+			w: Math.max(4, place(d.end) - place(d.start)),
+			y: bands.get(d) * 16
+		});
+		ctx.set(strips, { d: (d) => {
+			const b = stripBox(d);
+			return TimeMarks.bar(b.x, b.y, b.w, RIBBON, 3);
+		} });
+		ctx.hover(strips, (d) => ({
+			title: d.group,
+			color: ctx.palette.color(d.group),
+			rows: [["From", TimeRows.long(d.start)], ["To", TimeRows.long(d.end)]]
+		}));
+		const stripNames = ctx.marks("era-names", "text", ribbons.filter((d) => TimeRows.width(d.group, 10.5) + 8 < stripBox(d).w), (d) => d.group).attr("font-weight", 600).style("pointer-events", "none").text((d) => d.group);
+		ctx.text(ctx.set(stripNames, {
+			x: (d) => stripBox(d).x + 5,
+			y: (d) => stripBox(d).y + RIBBON - 4
+		}), 10.5, "ink");
+		const room = labelStyle === "label-beside" ? (+to - +from) / width * LABEL_ROOM : 0;
+		const rows = this.rows(spans, room);
+		const depth = Math.max(0, ...rows.values()) + 1;
+		const row = (height - header - 4) / depth, thick = Math.max(2, Math.min(mark === "bar" ? 18 : 2, row - 2));
+		const items = spans.map((span) => {
+			const x = place(span.start);
+			return {
+				span,
+				x,
+				w: Math.max(3, place(span.end) - x),
+				y: header + row * (rows.get(span) + .5),
+				key: `${span.label}/${span.index}`
+			};
+		});
+		const path = (d, w) => mark === "bar" ? TimeMarks.bar(d.x, d.y - thick / 2, w, thick, Math.min(4, thick / 2)) : `M${d.x},${d.y - 3}v6M${d.x},${d.y}h${w}M${d.x + w},${d.y - 3}v6`;
+		const color = (d) => ctx.palette.color(d.span.group);
+		const bars = ctx.marks("periods", "path", items, (d) => d.key).attr("fill", mark === "bar" ? color : "none").attr("stroke", mark === "bar" ? "none" : color).attr("stroke-width", 2);
+		ctx.set(bars, { d: (d) => path(d, d.w) }, { d: (d) => path(d, 0) }, 16);
+		ctx.hover(bars, ({ span }) => ({
+			title: span.label,
+			color: ctx.palette.color(span.group),
+			rows: [
+				["Era", span.group],
+				["From", TimeRows.long(span.start)],
+				["To", TimeRows.long(span.end)]
+			]
+		}));
+		const neighbour = (d) => Math.min(width, ...items.filter((o) => o !== d && Math.abs(o.y - d.y) < 1 && o.x > d.x).map((o) => o.x));
+		const beside = labelStyle === "label-beside";
+		const fits = (d) => row >= 11 && (beside ? d.x + d.w + 4 + TimeRows.width(d.span.label, 10) <= neighbour(d) : labelStyle === "label-inside" && thick >= 12 && TimeRows.width(d.span.label, 10) + 8 <= d.w);
+		const text = ctx.marks("labels", "text", items.filter(fits), (d) => d.key).style("pointer-events", "none").text((d) => d.span.label);
+		ctx.text(text, 10, "ink");
+		if (!beside) text.attr("fill", (d) => ctx.palette.inkOn(color(d)));
+		ctx.set(text, {
+			x: (d) => beside ? d.x + d.w + 4 : d.x + 5,
+			y: (d) => d.y + 3.5
+		});
+	}
+};
+export { ChronologyChart, ChronologyLabel, ChronologyMark, ChronologyPacking, ChronologyScale };

package/dist/charts/timeline/CriticalPathChart.js

@@ -0,0 +1,139 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { CriticalPathMethod } from "./CriticalPathMethod.js";
+import { TimeBandChart } from "./TimeBandChart.js";
+import { TimeMarks } from "./TimeMarks.js";
+import { TimeRows } from "./TimeRows.js";
+import { TimeSamples } from "./TimeSamples.js";
+// src/charts/timeline/CriticalPathChart.ts
+var CriticalSchedule = /* @__PURE__ */ function(CriticalSchedule) {
+	CriticalSchedule["Early"] = "early-start";
+	CriticalSchedule["Late"] = "late-start";
+	return CriticalSchedule;
+}({});
+var CriticalSlack = /* @__PURE__ */ function(CriticalSlack) {
+	CriticalSlack["Ghost"] = "slack-bar";
+	CriticalSlack["Whisker"] = "slack-whisker";
+	CriticalSlack["Hidden"] = "no-slack";
+	return CriticalSlack;
+}({});
+var CriticalSort = /* @__PURE__ */ function(CriticalSort) {
+	CriticalSort["Topological"] = "by-sequence";
+	CriticalSort["Slack"] = "by-slack";
+	CriticalSort["LateStart"] = "by-late-start";
+	return CriticalSort;
+}({});
+var CriticalLinks = /* @__PURE__ */ function(CriticalLinks) {
+	CriticalLinks["CriticalOnly"] = "critical-links";
+	CriticalLinks["All"] = "all-links";
+	CriticalLinks["Hidden"] = "no-links";
+	return CriticalLinks;
+}({});
+/** Find what really sets the finish date: tasks with no slack, and how much each other task can move. */
+var CriticalPathChart = class extends TimeBandChart {
+	static meta = {
+		id: "critical-path",
+		name: "Critical path chart",
+		family: ChartFamily.Project,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Computes the critical path of a task network and draws its schedule with slack for every other task.",
+		tags: [
+			"cpm",
+			"slack",
+			"float",
+			"schedule risk"
+		],
+		sample: (seed) => TimeSamples.plan(seed),
+		variants: {
+			schedule: Object.values(CriticalSchedule),
+			slack: Object.values(CriticalSlack),
+			sort: Object.values(CriticalSort),
+			links: Object.values(CriticalLinks)
+		}
+	};
+	defaults() {
+		return {
+			task: "task",
+			start: "start",
+			end: "end",
+			group: "group",
+			dependsOn: "dependsOn",
+			schedule: "early-start",
+			slack: "slack-bar",
+			sort: "by-sequence",
+			links: "critical-links"
+		};
+	}
+	bandPadding() {
+		return .26;
+	}
+	solved() {
+		const { data, task, start, end, group, dependsOn, duration, sort } = this.options;
+		const schedule = CriticalPathMethod.solve(data, {
+			task,
+			start,
+			end,
+			group,
+			dependsOn,
+			duration
+		});
+		const by = sort === "by-slack" ? (a, b) => a.slack - b.slack || a.earlyStart - b.earlyStart : sort === "by-late-start" ? (a, b) => a.lateStart - b.lateStart : (a, b) => a.earlyStart - b.earlyStart || a.rank - b.rank;
+		return {
+			...schedule,
+			tasks: [...schedule.tasks].sort(by)
+		};
+	}
+	origin({ origin }) {
+		return origin ?? TimeRows.floorDay(/* @__PURE__ */ new Date());
+	}
+	bands() {
+		return this.solved().tasks.map((task) => task.name);
+	}
+	range() {
+		const schedule = this.solved(), origin = this.origin(schedule);
+		return [origin, TimeRows.addDays(origin, Math.max(1, schedule.length))];
+	}
+	plotMarks(ctx, { x, y }) {
+		const schedule = this.solved(), origin = this.origin(schedule);
+		const { slack, links, schedule: mode } = this.options;
+		const at = (day) => x(TimeRows.addDays(origin, day));
+		const late = mode === "late-start";
+		const from = (task) => late ? task.lateStart : task.earlyStart;
+		const to = (task) => from(task) + task.duration;
+		const band = y.bandwidth(), top = (task) => y(task.name), mid = (task) => top(task) + band / 2;
+		const color = (task) => task.critical ? ctx.theme.critical : ctx.palette.color(task.group);
+		this.timeGrid(ctx, x);
+		const free = schedule.tasks.filter((task) => task.slack > 1e-6 && slack !== "no-slack");
+		const spare = (task) => late ? [task.earlyStart, task.lateStart] : [task.earlyFinish, task.lateFinish];
+		const ghosts = ctx.marks("slack", "path", free, (task) => task.name).attr("fill", slack === "slack-bar" ? ctx.theme.grid : "none").attr("stroke", slack === "slack-bar" ? "none" : ctx.theme.inkMuted).attr("stroke-width", 1.5);
+		ctx.set(ghosts, { d: (task) => {
+			const [a, b] = spare(task), left = at(a), right = at(b);
+			return slack === "slack-bar" ? TimeMarks.bar(left, top(task), right - left, band, Math.min(4, band / 2)) : `M${left},${mid(task)}H${right}M${right},${mid(task) - 3}v6`;
+		} });
+		const shown = links === "no-links" ? [] : schedule.links.filter((link) => links === "all-links" || link.critical);
+		const paths = ctx.marks("links", "path", shown, (d) => `${d.from.name}>${d.to.name}`).attr("fill", "none").attr("stroke", (d) => d.critical ? ctx.theme.critical : ctx.theme.axis).attr("stroke-width", (d) => d.critical ? 1.5 : 1);
+		ctx.set(paths, { d: ({ from: a, to: b }) => TimeMarks.connector(at(to(a)), mid(a), at(from(b)), mid(b)) });
+		const bar = (task, width) => TimeMarks.bar(at(from(task)), top(task), width, band, Math.min(4, band / 2));
+		const reach = (task) => Math.max(3, at(to(task)) - at(from(task)));
+		const bars = ctx.marks("tasks", "path", schedule.tasks, (task) => task.name).attr("fill", color);
+		ctx.set(bars, { d: (task) => bar(task, reach(task)) }, { d: (task) => bar(task, 0) }, 14);
+		ctx.hover(bars, (task) => ({
+			title: task.name,
+			color: color(task),
+			rows: [
+				["Duration", `${+task.duration.toFixed(1)} d`],
+				["Early start", TimeRows.long(TimeRows.addDays(origin, task.earlyStart))],
+				["Late start", TimeRows.long(TimeRows.addDays(origin, task.lateStart))],
+				["Slack", `${+task.slack.toFixed(1)} d`],
+				["Status", task.critical ? "Critical" : "Has slack"]
+			]
+		}));
+	}
+	legendItems() {
+		return [{
+			key: "Critical",
+			color: this.theme.critical
+		}, ...this.palette.items()];
+	}
+};
+export { CriticalLinks, CriticalPathChart, CriticalSchedule, CriticalSlack, CriticalSort };

package/dist/charts/timeline/CriticalPathMethod.js

@@ -0,0 +1,89 @@
+import { TimeRows } from "./TimeRows.js";
+// src/charts/timeline/CriticalPathMethod.ts
+var SPLIT = /\s*[,;]\s*/;
+var EPSILON = 1e-6;
+/** Forward and backward pass over a task table. Unknown predecessors are ignored and cycles are broken. */
+var CriticalPathMethod = class {
+	static solve(rows, fields) {
+		const tasks = this.tasks(rows, fields);
+		const byName = new Map(tasks.map((task) => [task.name, task]));
+		const order = this.topological(tasks, byName);
+		for (const task of order) {
+			const before = task.depends.map((name) => byName.get(name));
+			task.earlyStart = Math.max(0, ...before.map((other) => other.earlyFinish));
+			task.earlyFinish = task.earlyStart + task.duration;
+			task.rank = before.length ? 1 + Math.max(...before.map((other) => other.rank)) : 0;
+		}
+		const length = Math.max(0, ...tasks.map((task) => task.earlyFinish));
+		const after = new Map(tasks.map((task) => [task.name, []]));
+		for (const task of tasks) for (const name of task.depends) after.get(name).push(task);
+		for (const task of [...order].reverse()) {
+			task.lateFinish = Math.min(length, ...after.get(task.name).map((other) => other.lateStart));
+			task.lateStart = task.lateFinish - task.duration;
+			task.slack = task.lateStart - task.earlyStart;
+			task.critical = task.slack < EPSILON;
+		}
+		const links = tasks.flatMap((to) => to.depends.map((name) => {
+			const from = byName.get(name);
+			return {
+				from,
+				to,
+				critical: from.critical && to.critical && Math.abs(to.earlyStart - from.earlyFinish) < EPSILON
+			};
+		}));
+		const starts = rows.flatMap((row) => TimeRows.date(row[fields.start]) ?? []);
+		return {
+			tasks,
+			links,
+			length,
+			origin: starts.length ? new Date(Math.min(...starts.map(Number))) : null
+		};
+	}
+	static tasks(rows, fields) {
+		const seen = /* @__PURE__ */ new Map();
+		rows.forEach((row, index) => {
+			const name = TimeRows.text(row[fields.task], `#${index + 1}`);
+			const start = TimeRows.date(row[fields.start]), end = TimeRows.date(row[fields.end]);
+			const stated = fields.duration ? TimeRows.number(row[fields.duration]) : null;
+			const duration = Math.max(0, stated ?? (start && end ? TimeRows.days(start, end) : 0));
+			const depends = TimeRows.text(row[fields.dependsOn], "").split(SPLIT).filter((name) => name);
+			seen.set(name, {
+				name,
+				group: TimeRows.text(row[fields.group], "Other"),
+				duration,
+				depends,
+				row,
+				earlyStart: 0,
+				earlyFinish: duration,
+				lateStart: 0,
+				lateFinish: duration,
+				slack: 0,
+				critical: false,
+				rank: 0
+			});
+		});
+		const tasks = [...seen.values()];
+		for (const task of tasks) task.depends = [...new Set(task.depends)].filter((name) => seen.has(name) && name !== task.name);
+		return tasks;
+	}
+	/** Kahn's algorithm. Tasks left over form a cycle: their remaining predecessors are dropped. */
+	static topological(tasks, byName) {
+		const waiting = new Map(tasks.map((task) => [task, new Set(task.depends)]));
+		const order = [];
+		while (waiting.size) {
+			const ready = [...waiting].filter(([, needs]) => !needs.size).map(([task]) => task);
+			if (!ready.length) {
+				const [stuck] = [...waiting.keys()];
+				stuck.depends = stuck.depends.filter((name) => !waiting.has(byName.get(name)));
+				ready.push(stuck);
+			}
+			for (const task of ready) {
+				waiting.delete(task);
+				order.push(task);
+				for (const needs of waiting.values()) needs.delete(task.name);
+			}
+		}
+		return order;
+	}
+};
+export { CriticalPathMethod };