@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/structure/TournamentDraw.js

@@ -0,0 +1,209 @@
+import { TournamentStage } from "./structureEnums.js";
+// src/charts/structure/TournamentDraw.ts
+var number = (cell) => {
+	if (cell === null || cell === void 0 || cell === "") return null;
+	const value = +cell;
+	return Number.isFinite(value) ? value : null;
+};
+var BYE = {
+	team: null,
+	seed: null,
+	score: null,
+	bye: true
+};
+var OPEN = {
+	team: null,
+	seed: null,
+	score: null,
+	bye: false
+};
+/**
+* Builds a seeded elimination draw from one row per team per round played. Pairings follow from
+* the seeds and the scores, so a tournament still in progress simply leaves later games open.
+* Top seeds take the byes when the field is not a power of two. Level scores advance the better seed.
+*/
+var TournamentDraw = class TournamentDraw {
+	winners = [];
+	losers = [];
+	finals = [];
+	thirdPlace = null;
+	size;
+	entrants;
+	#scores = /* @__PURE__ */ new Map();
+	#seeds = /* @__PURE__ */ new Map();
+	/** Seat order for a power-of-two draw: 1 and 2 at opposite ends, every pair summing to `size + 1`. */
+	static seats(size) {
+		if (size <= 2) return [1, 2];
+		return TournamentDraw.seats(size / 2).flatMap((seed, i) => i % 2 ? [size + 1 - seed, seed] : [seed, size + 1 - seed]);
+	}
+	/** Round heading, longest first: `Quarterfinals`, then the short form for tight columns. */
+	static roundName(round, rounds) {
+		const left = rounds - round;
+		if (left === 0) return ["Final", "F"];
+		if (left === 1) return ["Semifinals", "SF"];
+		if (left === 2) return ["Quarterfinals", "QF"];
+		return [`Round of ${2 ** (left + 1)}`, `R${2 ** (left + 1)}`];
+	}
+	constructor(rows, fields, format) {
+		this.entrants = this.#read(rows, fields);
+		this.size = this.entrants.length ? 2 ** Math.ceil(Math.log2(Math.max(2, this.entrants.length))) : 0;
+		if (!this.size) return;
+		this.#buildWinners();
+		if (format.double) this.#buildLosers();
+		if (format.double) this.#buildFinals(format.reset);
+		if (!format.double && format.thirdPlace && this.winners.length >= 2) this.thirdPlace = this.#buildThirdPlace();
+		let next = 1;
+		for (const game of this.games) if (!this.hidden(game) && !game.moot) game.number = next++;
+	}
+	get games() {
+		return [
+			...this.winners.flat(),
+			...this.losers.flat(),
+			...this.finals,
+			...this.thirdPlace ? [this.thirdPlace] : []
+		];
+	}
+	get champion() {
+		const [first, reset] = this.finals;
+		if (!first) return TournamentDraw.#taken(this.winners.at(-1)?.at(-1));
+		if (first.winner === 0 || !reset) return TournamentDraw.#taken(first);
+		return TournamentDraw.#taken(reset);
+	}
+	/** Empty games are not drawn, except a lone entrant's final. */
+	hidden(game) {
+		return game.empty && game !== this.winners.at(-1)?.at(-1);
+	}
+	/** The drawn game feeding `side`, looking through empty games. */
+	feed(game, side) {
+		const walk = (from) => {
+			if (!from || !this.hidden(from)) return from;
+			return walk(from.feeds[0]) ?? walk(from.feeds[1]);
+		};
+		return walk(game.feeds[side]);
+	}
+	static #taken(game) {
+		return game && game.winner !== null ? game.sides[game.winner].team : null;
+	}
+	#read(rows, fields) {
+		const stated = /* @__PURE__ */ new Map();
+		for (const row of rows) {
+			const cell = row[fields.team];
+			if (cell === null || cell === void 0 || cell === "") continue;
+			const team = String(cell);
+			if (!stated.has(team) || stated.get(team) === null) stated.set(team, number(row[fields.seed]));
+			const score = number(row[fields.score]), key = this.#key(row[fields.stage], number(row[fields.round]) ?? 1, team);
+			if (score !== null && !this.#scores.has(key)) this.#scores.set(key, score);
+		}
+		const order = [...stated].map(([team, seed], i) => ({
+			team,
+			seed: seed ?? Infinity,
+			i
+		})).sort((a, b) => a.seed - b.seed || a.i - b.i);
+		order.forEach(({ team }, i) => this.#seeds.set(team, i + 1));
+		return order.map(({ team }) => team);
+	}
+	#key(stage, round, team) {
+		return `${stage ?? TournamentStage.Winners}|${round}|${team}`;
+	}
+	#entrant(seed) {
+		const team = this.entrants[seed - 1];
+		return team === void 0 ? BYE : {
+			team,
+			seed,
+			score: null,
+			bye: false
+		};
+	}
+	#game(stage, round, index, sides, feeds = [null, null], drops = [null, null]) {
+		const scored = sides.map((side) => side.team === null ? side : {
+			...side,
+			score: this.#scores.get(this.#key(stage, round, side.team)) ?? null
+		});
+		const [a, b] = scored;
+		const game = {
+			stage,
+			round,
+			index,
+			number: 0,
+			sides: scored,
+			feeds,
+			drops,
+			winner: null,
+			empty: a.bye || b.bye,
+			moot: false
+		};
+		if (a.bye !== b.bye && (a.team ?? b.team) !== null) game.winner = a.bye ? 1 : 0;
+		if (a.team !== null && b.team !== null && a.score !== null && b.score !== null) game.winner = a.score === b.score ? a.seed < b.seed ? 0 : 1 : a.score > b.score ? 0 : 1;
+		return game;
+	}
+	#won(game) {
+		if (game.sides[0].bye && game.sides[1].bye) return BYE;
+		return game.winner === null ? OPEN : {
+			...game.sides[game.winner],
+			score: null
+		};
+	}
+	#lost(game) {
+		if (game.empty) return BYE;
+		return game.winner === null ? OPEN : {
+			...game.sides[game.winner === 0 ? 1 : 0],
+			score: null
+		};
+	}
+	#buildWinners() {
+		const seats = TournamentDraw.seats(this.size);
+		const rounds = Math.round(Math.log2(this.size));
+		this.winners.push(Array.from({ length: this.size / 2 }, (_, i) => this.#game(TournamentStage.Winners, 1, i, [this.#entrant(seats[i * 2]), this.#entrant(seats[i * 2 + 1])])));
+		for (let round = 2; round <= rounds; round++) {
+			const before = this.winners.at(-1);
+			this.winners.push(Array.from({ length: before.length / 2 }, (_, i) => {
+				const a = before[i * 2], b = before[i * 2 + 1];
+				return this.#game(TournamentStage.Winners, round, i, [this.#won(a), this.#won(b)], [a, b]);
+			}));
+		}
+	}
+	/** Drop-ins swap with their neighbour, so a loser never lands in the half that holds the team that beat them. */
+	#buildLosers() {
+		const stage = TournamentStage.Losers;
+		const rounds = 2 * (this.winners.length - 1);
+		for (let round = 1; round <= rounds; round++) {
+			const before = this.losers.at(-1);
+			if (round === 1) {
+				const first = this.winners[0];
+				this.losers.push(Array.from({ length: first.length / 2 }, (_, i) => {
+					const a = first[i * 2], b = first[i * 2 + 1];
+					return this.#game(stage, 1, i, [this.#lost(a), this.#lost(b)], [null, null], [a, b]);
+				}));
+			} else if (round % 2 === 0) {
+				const dropping = this.winners[round / 2];
+				this.losers.push(before.map((game, i) => {
+					const from = dropping[dropping.length > 1 ? i ^ 1 : i];
+					return this.#game(stage, round, i, [this.#won(game), this.#lost(from)], [game, null], [null, from]);
+				}));
+			} else this.losers.push(Array.from({ length: before.length / 2 }, (_, i) => {
+				const a = before[i * 2], b = before[i * 2 + 1];
+				return this.#game(stage, round, i, [this.#won(a), this.#won(b)], [a, b]);
+			}));
+		}
+	}
+	#buildFinals(reset) {
+		const stage = TournamentStage.Final;
+		const top = this.winners.at(-1)[0], bottom = this.losers.at(-1)?.[0] ?? null;
+		const first = this.#game(stage, 1, 0, [this.#won(top), bottom ? this.#won(bottom) : this.#lost(top)], [top, bottom], [null, bottom ? null : top]);
+		this.finals.push(first);
+		if (!reset) return;
+		const moot = first.winner === 0;
+		const rematch = first.winner === null ? [OPEN, OPEN] : first.sides.map((side) => ({
+			...side,
+			score: null
+		}));
+		const second = this.#game(stage, 2, 0, moot ? [OPEN, OPEN] : rematch, [first, null]);
+		second.moot = moot;
+		this.finals.push(second);
+	}
+	#buildThirdPlace() {
+		const [a, b] = this.winners.at(-2);
+		return this.#game(TournamentStage.ThirdPlace, 1, 0, [this.#lost(a), this.#lost(b)], [null, null], [a, b]);
+	}
+};
+export { TournamentDraw };

package/dist/charts/structure/TournamentLayout.js

@@ -0,0 +1,216 @@
+import { StructureText } from "./StructureText.js";
+import { TournamentStage } from "./structureEnums.js";
+import { TournamentDraw } from "./TournamentDraw.js";
+// src/charts/structure/TournamentLayout.ts
+var HEADING = 16;
+var MAX_ROW = 20;
+/** Turns a draw into positions. Sheet style hangs names on rules that join at each round; card style boxes each game. */
+var TournamentLayout = class TournamentLayout {
+	#draw;
+	#box;
+	#mirrored;
+	#sheet;
+	#seats = /* @__PURE__ */ new Map();
+	#cols = 1;
+	#rowHeight = MAX_ROW;
+	#headings = [];
+	static plan(draw, box, mirrored, sheet) {
+		return new TournamentLayout(draw, box, mirrored, sheet).#plan();
+	}
+	constructor(draw, box, mirrored, sheet) {
+		this.#draw = draw;
+		this.#box = box;
+		this.#mirrored = mirrored;
+		this.#sheet = sheet;
+	}
+	#plan() {
+		const draw = this.#draw;
+		if (!draw.winners.length) return {
+			games: [],
+			headings: [],
+			links: [],
+			rowHeight: MAX_ROW
+		};
+		if (draw.finals.length) this.#seatDouble();
+		else this.#seatSingle();
+		const gap = Math.min(20, this.#box.width / this.#cols * .18);
+		const width = (this.#box.width - gap * (this.#cols - 1)) / this.#cols;
+		const x = (col) => col * (width + gap);
+		const placed = /* @__PURE__ */ new Map();
+		const games = draw.games.filter((game) => !draw.hidden(game)).map((game) => {
+			const at = this.#place(game, x(this.#seats.get(game).col), width, placed);
+			placed.set(game, at);
+			return at;
+		});
+		const links = games.flatMap((to) => [0, 1].flatMap((side) => {
+			const source = draw.feed(to.game, side);
+			if (!source) return [];
+			const from = placed.get(source);
+			const rightward = to.x >= from.x;
+			const x1 = rightward ? from.x + from.width : from.x, x2 = rightward ? to.x : to.x + to.width;
+			const bend = x2 + (rightward ? -gap / 2 : gap / 2);
+			const team = source.winner === null ? null : source.sides[source.winner].team;
+			return [{
+				key: `${to.game.stage}-${to.game.round}-${to.game.index}-${side}`,
+				d: `M${x1},${from.exit}H${bend}V${to.entries[side]}H${x2}`,
+				champion: team !== null && team === draw.champion
+			}];
+		}));
+		return {
+			games,
+			headings: this.#headings.map(({ key, names, col, y }) => {
+				const long = StructureText.width(names[0], 10.5) <= width;
+				return {
+					key,
+					text: StructureText.fit(long ? names[0] : names[1], width, 10.5),
+					x: x(col),
+					y,
+					width
+				};
+			}),
+			links,
+			rowHeight: this.#rowHeight
+		};
+	}
+	#place(game, x, width, placed) {
+		const { cy, flow } = this.#seats.get(game), row = this.#rowHeight;
+		const edge = flow === 0 ? null : flow > 0 ? x + width : x;
+		if (!this.#sheet) return {
+			game,
+			x,
+			width,
+			tops: [cy - row - 1, cy + 1],
+			entries: [cy, cy],
+			exit: cy,
+			edge
+		};
+		const [a, b] = [0, 1].map((side) => {
+			const feed = this.#draw.feed(game, side);
+			return feed ? placed.get(feed).exit : null;
+		});
+		const apart = a !== null && b !== null && Math.abs(b - a) >= row * 1.6;
+		const first = apart ? a : a ?? b ?? cy;
+		const second = apart ? b : first + row;
+		return {
+			game,
+			x,
+			width,
+			tops: [first - row, second - row],
+			entries: [first, second],
+			exit: (first + second) / 2,
+			edge
+		};
+	}
+	#seatSingle() {
+		const { winners, thirdPlace } = this.#draw;
+		const rounds = winners.length;
+		const band = thirdPlace ? Math.min(58, this.#box.height * .24) : 0;
+		const height = this.#box.height - HEADING - band;
+		const mirrored = this.#mirrored && rounds > 1;
+		this.#cols = mirrored ? 2 * rounds - 1 : rounds;
+		const unit = height / (mirrored ? winners[0].length / 2 : winners[0].length);
+		this.#rowHeight = Math.min(MAX_ROW, unit * .42);
+		winners.forEach((games, r) => games.forEach((game, i) => {
+			const half = games.length / 2, right = mirrored && r < rounds - 1 && i >= half;
+			const cy = r === 0 ? HEADING + ((right ? i - half : i) + .5) * unit : this.#mean(game);
+			const flow = !mirrored ? 1 : r === rounds - 1 ? 0 : right ? -1 : 1;
+			this.#seats.set(game, {
+				col: mirrored && right ? this.#cols - 1 - r : r,
+				cy,
+				flow
+			});
+		}));
+		winners.forEach((_, r) => {
+			const names = TournamentDraw.roundName(r + 1, rounds);
+			this.#headings.push({
+				key: `w${r}`,
+				names,
+				col: r,
+				y: 11
+			});
+			if (mirrored && r < rounds - 1) this.#headings.push({
+				key: `m${r}`,
+				names,
+				col: this.#cols - 1 - r,
+				y: 11
+			});
+		});
+		if (!thirdPlace) return;
+		const col = rounds - 1, row = this.#rowHeight;
+		const cy = this.#box.height - row - 1;
+		this.#seats.set(thirdPlace, {
+			col,
+			cy,
+			flow: 1
+		});
+		this.#headings.push({
+			key: "third",
+			names: ["Third place", "3rd"],
+			col,
+			y: cy - row - 6
+		});
+	}
+	/** Winners above, losers below, sharing columns so both finals reach the grand final side by side. */
+	#seatDouble() {
+		const { winners, losers, finals } = this.#draw;
+		const rounds = winners.length;
+		const lastCol = Math.max(rounds, losers.length) - 1;
+		this.#cols = lastCol + 1 + finals.length;
+		const upper = winners[0].length, lower = Math.max(1, losers[0]?.length ?? 0);
+		const unit = (this.#box.height - 32) / (upper + lower);
+		this.#rowHeight = Math.min(MAX_ROW, unit * .42);
+		const lowerTop = 32 + upper * unit;
+		const winnerCol = (r) => rounds > 1 ? Math.round(r * lastCol / (rounds - 1)) : 0;
+		winners.forEach((games, r) => {
+			games.forEach((game, i) => this.#seats.set(game, {
+				col: winnerCol(r),
+				cy: r === 0 ? HEADING + (i + .5) * unit : this.#mean(game),
+				flow: 1
+			}));
+			this.#headings.push({
+				key: `w${r}`,
+				names: r === rounds - 1 ? ["Winners final", "WF"] : [`Winners ${r + 1}`, `W${r + 1}`],
+				col: winnerCol(r),
+				y: 11
+			});
+		});
+		losers.forEach((games, r) => {
+			games.forEach((game, i) => this.#seats.set(game, {
+				col: r,
+				cy: r === 0 ? lowerTop + (i + .5) * unit : this.#mean(game),
+				flow: 1
+			}));
+			this.#headings.push({
+				key: `l${r}`,
+				names: r === losers.length - 1 ? ["Losers final", "LF"] : [`Losers ${r + 1}`, `L${r + 1}`],
+				col: r,
+				y: lowerTop - 5
+			});
+		});
+		finals.forEach((game, i) => {
+			const cy = i === 0 ? this.#mean(game) : this.#seats.get(finals[0]).cy;
+			this.#seats.set(game, {
+				col: lastCol + 1 + i,
+				cy,
+				flow: 1
+			});
+			this.#headings.push({
+				key: `f${i}`,
+				names: i === 0 ? ["Grand final", "GF"] : ["Reset", "Reset"],
+				col: lastCol + 1 + i,
+				y: 11
+			});
+		});
+	}
+	#mean(game) {
+		const seats = game.feeds.filter((feed) => feed !== null).map((feed) => this.#seats.get(feed).cy);
+		return seats.reduce((sum, cy) => sum + cy, 0) / seats.length;
+	}
+	static stageName(game, rounds, losers) {
+		if (game.stage === TournamentStage.ThirdPlace) return "Third place";
+		if (game.stage === TournamentStage.Final) return game.round === 1 ? "Grand final" : "Bracket reset";
+		if (game.stage === TournamentStage.Losers) return game.round === losers ? "Losers final" : `Losers round ${game.round}`;
+		return TournamentDraw.roundName(game.round, rounds)[0];
+	}
+};
+export { TournamentLayout };