@johnmorrisdotca/taisen-brackets 0.0.0-stage → 0.1.0

package/dist/seeding.d.ts

@@ -0,0 +1,60 @@
+import type { Matchup, SideId, Team } from "./types.ts";
+/**
+ * The seeds in the order a standard bracket lists them, so that 1 meets 2 only in the final and the top seeds meet the
+ * bottom ones first: `standardSeeds(8)` is `[1, 8, 4, 5, 2, 7, 3, 6]`. `size` is rounded up to a power of two.
+ */
+export declare function standardSeeds(size: number): number[];
+export interface SingleEliminationOptions {
+    /** Add a third-place match between the losing semi-finalists. Default false. */
+    thirdPlace?: boolean;
+    /** The ids of the ties are `${prefix}1-1`, `${prefix}1-2`… (round, then place in the round). Default "R". */
+    prefix?: string;
+}
+/**
+ * The matchups of a single-elimination bracket for any number of teams, seeded in the standard way: the top seeds meet
+ * the lowest first, and when the number is not a power of two the top seeds have byes. The teams are in seed order
+ * (or carry a `seed`). No tie has a result yet; fill the results in and call `advanceWinners` to carry them forward.
+ */
+export declare function singleElimination(teams: readonly Team[], options?: SingleEliminationOptions): {
+    teams: Team[];
+    matchups: Matchup[];
+};
+/**
+ * Fills the sides of every tie from the ties that feed it: a decided tie's winner takes its place in the next tie (the
+ * loser, for a third-place match). Returns new matchups; the ones given are not changed. Ties are filled in the order of
+ * the rounds, so a result for a later round is read against the sides this has just filled in.
+ */
+export declare function advanceWinners(matchups: readonly Matchup[]): Matchup[];
+/** One played game, in the flat shape that most data sources give. */
+export interface PlayedGame {
+    /** The stage it was played in: a key from `stages`, or the `third` one. */
+    stage: string;
+    home: SideId;
+    away: SideId;
+    homeScore: number;
+    awayScore: number;
+    date?: string;
+    extraTime?: boolean;
+    homePens?: number;
+    awayPens?: number;
+    /** A replay of a drawn game. */
+    replay?: boolean;
+    /** An order within the stage (a match number). */
+    no?: number;
+}
+export interface GamesOptions {
+    /** The knockout stages in order, first round first: `["round-of-16", "quarter-final", "semi-final", "final"]`. */
+    stages: readonly string[];
+    /** The stage of the third-place match, if the data has one. */
+    third?: string;
+    /** Stages played in two legs, added up. Several games of one pair in any other stage are a replay. */
+    aggregate?: readonly string[];
+    /** Stages played as a series, with their length: `{ final: 7 }`. */
+    series?: Readonly<Record<string, number>>;
+}
+/**
+ * Matchups from a flat list of games: the games of one pair in one stage become one tie (a replay, two legs or a series),
+ * the stage orders the rounds, and the third-place stage becomes the third-place match. The sides of a tie are the home
+ * and away of its first game; each game's score is turned to that order.
+ */
+export declare function matchupsFromGames(games: readonly PlayedGame[], options: GamesOptions): Matchup[];

package/dist/seeding.js

@@ -0,0 +1,141 @@
+import { collectTeams, resolveMatchup } from "./matchup.js";
+/**
+ * The seeds in the order a standard bracket lists them, so that 1 meets 2 only in the final and the top seeds meet the
+ * bottom ones first: `standardSeeds(8)` is `[1, 8, 4, 5, 2, 7, 3, 6]`. `size` is rounded up to a power of two.
+ */
+export function standardSeeds(size) {
+    if (!Number.isInteger(size) || size < 1)
+        throw new Error(`taisen-brackets: standardSeeds needs a whole number of 1 or more, not ${size}`);
+    let seeds = [1];
+    while (seeds.length < size) {
+        const total = seeds.length * 2;
+        seeds = seeds.flatMap((s) => [s, total + 1 - s]);
+    }
+    return seeds;
+}
+/**
+ * The matchups of a single-elimination bracket for any number of teams, seeded in the standard way: the top seeds meet
+ * the lowest first, and when the number is not a power of two the top seeds have byes. The teams are in seed order
+ * (or carry a `seed`). No tie has a result yet; fill the results in and call `advanceWinners` to carry them forward.
+ */
+export function singleElimination(teams, options = {}) {
+    const count = teams.length;
+    if (count < 2)
+        throw new Error("taisen-brackets: a bracket needs at least two teams");
+    const bySeed = teams.every((t) => t.seed !== undefined) ? [...teams].sort((a, b) => a.seed - b.seed) : [...teams];
+    const seeded = bySeed.map((t, i) => ({ ...t, seed: t.seed ?? i + 1 }));
+    const slots = standardSeeds(count);
+    const size = slots.length;
+    const rounds = Math.log2(size);
+    const prefix = options.prefix ?? "R";
+    const teamAt = (seed) => seeded.find((t) => t.seed === seed) ?? null;
+    const matchups = [];
+    const node = (round, k) => {
+        if (round === 1) {
+            const a = teamAt(slots[2 * k]), b = teamAt(slots[2 * k + 1]);
+            if (a && !b)
+                return { team: a };
+            if (b && !a)
+                return { team: b };
+            const id = `${prefix}1-${k + 1}`;
+            matchups.push({ id, round: 1, sides: [a.id, b.id] });
+            return { tie: id };
+        }
+        const left = node(round - 1, 2 * k), right = node(round - 1, 2 * k + 1);
+        const id = `${prefix}${round}-${k + 1}`;
+        const side = (n) => ("team" in n ? n.team.id : null);
+        const feed = (n) => ("tie" in n ? n.tie : null);
+        matchups.push({ id, round, sides: [side(left), side(right)], feeds: [feed(left), feed(right)] });
+        return { tie: id };
+    };
+    node(rounds, 0);
+    if (options.thirdPlace && rounds >= 2) {
+        const semis = matchups.filter((m) => m.round === rounds - 1).map((m) => m.id);
+        matchups.push({ id: `${prefix}3rd`, round: rounds, third: true, sides: [null, null], feeds: [semis[0] ?? null, semis[1] ?? null] });
+    }
+    return { teams: seeded, matchups };
+}
+/**
+ * Fills the sides of every tie from the ties that feed it: a decided tie's winner takes its place in the next tie (the
+ * loser, for a third-place match). Returns new matchups; the ones given are not changed. Ties are filled in the order of
+ * the rounds, so a result for a later round is read against the sides this has just filled in.
+ */
+export function advanceWinners(matchups) {
+    let current = matchups.map((m) => ({ ...m }));
+    for (let pass = 0; pass < current.length; pass++) {
+        const teams = collectTeams(current);
+        // A tie whose winner is named before its sides are filled in cannot be read yet; it is undecided until they are.
+        const at = new Map();
+        current.forEach((m, i) => { try {
+            const t = resolveMatchup(m, i, teams);
+            at.set(t.id, t);
+        }
+        catch { /* not yet */ } });
+        let changed = false;
+        current = current.map((m) => {
+            if (!m.feeds)
+                return m;
+            let touched = false;
+            const sides = [...m.sides];
+            m.feeds.forEach((feed, k) => {
+                if (feed == null)
+                    return;
+                const child = at.get(feed);
+                if (!child || child.winner === null)
+                    return;
+                const team = child.sides[m.third ? (1 - child.winner) : child.winner];
+                const here = sides[k];
+                if (team && (here !== null && typeof here === "object" ? here.id : here) !== team.id) {
+                    sides[k] = team.id;
+                    touched = true;
+                    changed = true;
+                }
+            });
+            return touched ? { ...m, sides } : m;
+        });
+        if (!changed)
+            break;
+    }
+    return current;
+}
+/**
+ * Matchups from a flat list of games: the games of one pair in one stage become one tie (a replay, two legs or a series),
+ * the stage orders the rounds, and the third-place stage becomes the third-place match. The sides of a tie are the home
+ * and away of its first game; each game's score is turned to that order.
+ */
+export function matchupsFromGames(games, options) {
+    const sorted = [...games].sort((a, b) => (a.date ?? "") < (b.date ?? "") ? -1 : (a.date ?? "") > (b.date ?? "") ? 1 : 0);
+    const groups = new Map();
+    for (const g of sorted) {
+        if (g.stage !== options.third && !options.stages.includes(g.stage))
+            throw new Error(`taisen-brackets: game stage ${JSON.stringify(g.stage)} is not in stages`);
+        const pair = [String(g.home), String(g.away)].sort().join("|");
+        const key = `${g.stage}|${pair}`;
+        groups.set(key, [...(groups.get(key) ?? []), g]);
+    }
+    const out = [];
+    for (const list of groups.values()) {
+        const head = list[0];
+        const sides = [head.home, head.away];
+        const turned = list.map((g) => {
+            const flip = g.home !== head.home;
+            const pair = (a, b) => (flip ? [b, a] : [a, b]);
+            const pens = g.homePens !== undefined && g.awayPens !== undefined ? pair(g.homePens, g.awayPens) : undefined;
+            return { score: pair(g.homeScore, g.awayScore), date: g.date, extraTime: g.extraTime, pens, replay: g.replay };
+        });
+        const third = head.stage === options.third;
+        const round = third ? options.stages.length : options.stages.indexOf(head.stage) + 1;
+        const m = { id: `${head.stage}-${out.length + 1}`, sides, round, games: turned, no: head.no, third };
+        if (options.aggregate?.includes(head.stage))
+            m.kind = "aggregate";
+        else if (options.series?.[head.stage]) {
+            m.kind = "series";
+            m.bestOf = options.series[head.stage];
+        }
+        else if (list.length > 1)
+            turned.forEach((g, i) => { if (i > 0)
+                g.replay = true; });
+        out.push(m);
+    }
+    return out;
+}

package/dist/table.d.ts

@@ -0,0 +1,14 @@
+import type { BracketInput, BracketLayout, DrawOptions, Matchup, Words } from "./types.ts";
+export interface TableOptions {
+    words?: Partial<Words>;
+    roundNames?: DrawOptions["roundNames"];
+    /** The table's caption. Default: the summary ("16 teams, 4 rounds"). */
+    caption?: string;
+    /** A class for the `<table>`. Default `tb-table`. */
+    className?: string;
+}
+/**
+ * The bracket as an HTML table, for a reader the drawing does not serve: one row for every tie, round by round, with the
+ * two sides, the score, the winner in bold and a note. It is a plain, valid `<table>` with a caption and header cells.
+ */
+export declare function bracketTable(input: BracketLayout | readonly Matchup[] | BracketInput, options?: TableOptions): string;

package/dist/table.js

@@ -0,0 +1,35 @@
+import { layoutBracket } from "./layout.js";
+import { noteParts } from "./matchup.js";
+import { roundLabel } from "./rounds.js";
+import { esc } from "./text.js";
+import { fill, wordsWith } from "./words.js";
+/**
+ * The bracket as an HTML table, for a reader the drawing does not serve: one row for every tie, round by round, with the
+ * two sides, the score, the winner in bold and a note. It is a plain, valid `<table>` with a caption and header cells.
+ */
+export function bracketTable(input, options = {}) {
+    const layout = "ties" in input && "rounds" in input ? input : layoutBracket(input);
+    const words = wordsWith(options.words);
+    const caption = options.caption ?? fill(layout.rounds === 1 ? words.summaryOne : words.summary, { n: layout.teams.length, r: layout.rounds });
+    const order = layout.ties
+        .filter((t) => t.round > 0 || layout.robin.includes(t.index))
+        .sort((a, b) => Number(a.third) - Number(b.third) || a.round - b.round || (a.date < b.date ? -1 : a.date > b.date ? 1 : a.index - b.index));
+    const name = (t, k) => {
+        const team = t.sides[k];
+        const text = team ? esc(team.name) : esc(words.tbd);
+        return t.winner === k ? `<strong>${text}</strong>` : text;
+    };
+    const score = (t) => (t.result.score ? `${t.result.score[0]}–${t.result.score[1]}` : "");
+    const rows = order.map((t) => {
+        const roundText = t.third ? words.thirdPlace : t.round === 0 ? "" : roundLabel(layout, t.round, options.roundNames, words);
+        const note = noteParts(t, words).map((part) => (part === words.pens && t.result.pens ? `${words.pens} ${t.result.pens[0]}–${t.result.pens[1]}` : part)).join(", ");
+        return `<tr><th scope="row">${esc(roundText)}</th><td>${name(t, 0)}</td><td>${esc(score(t))}</td><td>${name(t, 1)}</td><td>${esc(note)}</td></tr>`;
+    });
+    return [
+        `<table class="${esc(options.className ?? "tb-table")}">`,
+        `<caption>${esc(caption)}</caption>`,
+        `<thead><tr><th scope="col">${esc(words.columnRound)}</th><th scope="col" colspan="3">${esc(words.columnTie)}</th><th scope="col">${esc(words.columnNote)}</th></tr></thead>`,
+        `<tbody>${rows.join("")}</tbody>`,
+        "</table>",
+    ].join("\n");
+}

package/dist/text.d.ts

@@ -0,0 +1,16 @@
+/** Text helpers: escaping, an estimate of how wide a line is, and trimming it to fit. Pure, no DOM, no font files. */
+/** Escapes text for an XML or HTML text node or an attribute value. */
+export declare function esc(text: string | number): string;
+/**
+ * About how wide a line is at a font size, in the same units. An estimate from character classes (a system sans):
+ * the same on every machine, so that a drawing is the same string everywhere. It can be a few percent off a real font.
+ */
+export declare function textWidth(text: string, size: number): number;
+/** The text cut to fit a width, with an ellipsis where it was cut. */
+export declare function fit(text: string, size: number, width: number): string;
+/** A short name for a small box: the initials of a name of several words ("NYR"), else its first three letters; capitals. */
+export declare function abbreviate(name: string): string;
+/** A small, stable hash of a string as lowercase base 36, for ids that depend on the content and nothing else. */
+export declare function hash(text: string): string;
+/** A number written without float noise: at most two decimals, no trailing zeros. */
+export declare function num(n: number): string;

package/dist/text.js

@@ -0,0 +1,62 @@
+/** Text helpers: escaping, an estimate of how wide a line is, and trimming it to fit. Pure, no DOM, no font files. */
+/** Escapes text for an XML or HTML text node or an attribute value. */
+export function esc(text) {
+    return String(text).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+const NARROW = new Set("iIjlt1.,:;!|'`()[]/ ");
+const WIDE = new Set("mwMW@%");
+/**
+ * About how wide a line is at a font size, in the same units. An estimate from character classes (a system sans):
+ * the same on every machine, so that a drawing is the same string everywhere. It can be a few percent off a real font.
+ */
+export function textWidth(text, size) {
+    let em = 0;
+    for (const ch of text) {
+        const code = ch.codePointAt(0) ?? 0;
+        if (code >= 0x2e80)
+            em += 1;
+        else if (NARROW.has(ch))
+            em += 0.3;
+        else if (WIDE.has(ch))
+            em += 0.86;
+        else if (ch >= "A" && ch <= "Z")
+            em += 0.66;
+        else if (ch >= "0" && ch <= "9")
+            em += 0.56;
+        else
+            em += 0.54;
+    }
+    return em * size;
+}
+/** The text cut to fit a width, with an ellipsis where it was cut. */
+export function fit(text, size, width) {
+    if (textWidth(text, size) <= width)
+        return text;
+    const chars = [...text];
+    while (chars.length > 1 && textWidth(`${chars.join("")}…`, size) > width)
+        chars.pop();
+    return chars.length <= 1 && textWidth(text, size) > width * 2 ? "…" : `${chars.join("").trimEnd()}…`;
+}
+/** A short name for a small box: the initials of a name of several words ("NYR"), else its first three letters; capitals. */
+export function abbreviate(name) {
+    const words = name.trim().split(/\s+/).filter(Boolean);
+    const letters = (word) => [...word].filter((c) => /\p{L}/u.test(c));
+    const made = words.length > 1 ? words.map((w) => letters(w)[0] ?? "").join("").slice(0, 3) : letters(words[0] ?? "").slice(0, 3).join("");
+    return (made || name.slice(0, 3)).toUpperCase();
+}
+/** A small, stable hash of a string as lowercase base 36, for ids that depend on the content and nothing else. */
+export function hash(text) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < text.length; i++) {
+        h ^= text.charCodeAt(i);
+        h = Math.imul(h, 0x01000193) >>> 0;
+    }
+    return h.toString(36);
+}
+/** A number written without float noise: at most two decimals, no trailing zeros. */
+export function num(n) {
+    if (!Number.isFinite(n))
+        throw new Error(`taisen-brackets: cannot draw ${n}`);
+    const r = Math.round(n * 100) / 100;
+    return Object.is(r, -0) ? "0" : String(r);
+}

package/dist/theme.d.ts

@@ -0,0 +1,21 @@
+import type { ThemeName } from "./types.ts";
+/** The colours of one look. Each is the fallback of a CSS custom property of the same name: `--tb-ink` and so on. */
+export interface Palette {
+    bg: string;
+    ink: string;
+    muted: string;
+    line: string;
+    box: string;
+    edge: string;
+    win: string;
+    gold: string;
+    plain: string;
+}
+/** The looks. Every colour is the fallback for a custom property, so a page can restyle a drawing with `--tb-ink: …` and nothing else. */
+export declare const THEMES: Readonly<Record<"light" | "dark" | "poster", Palette>>;
+/**
+ * The `<style>` text of a drawing. `auto` is the light look and, under `prefers-color-scheme: dark` or a page that says
+ * `data-theme="dark"` on `<html>`, the dark one; `light`, `dark` and `poster` are one look always. Every colour can be
+ * set from the page with a `--tb-*` custom property.
+ */
+export declare function styleFor(scope: string, theme: Exclude<ThemeName, "none">): string;

package/dist/theme.js

@@ -0,0 +1,53 @@
+/** The looks. Every colour is the fallback for a custom property, so a page can restyle a drawing with `--tb-ink: …` and nothing else. */
+export const THEMES = Object.freeze({
+    light: { bg: "#f4efe4", ink: "#1f2320", muted: "#62665f", line: "#8d9087", box: "#fbf8f1", edge: "#cfc7b3", win: "#b5452c", gold: "#845f06", plain: "#d9d3c2" },
+    dark: { bg: "#141614", ink: "#ece8dc", muted: "#9aa095", line: "#6c7168", box: "#1e211d", edge: "#3b403a", win: "#e0705a", gold: "#e0b43b", plain: "#3b403a" },
+    poster: { bg: "#0a1130", ink: "#f6f1e3", muted: "#a9b2d3", line: "#d9b24c", box: "#111b47", edge: "#8e7632", win: "#f0c64a", gold: "#f0c64a", plain: "#26336b" },
+});
+const FONT = 'system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif';
+/** The rules for one palette, each colour read from its custom property with the palette's value as the fallback. */
+function rules(p, poster, withFont) {
+    const v = (name) => `var(--tb-${name}, ${p[name]})`;
+    const list = [
+        [[".tb-bg"], `fill:${v("bg")}`],
+        [[".tb-line"], `stroke:${v("line")};stroke-width:${poster ? 1.6 : 1.3};fill:none;stroke-opacity:${poster ? 0.95 : 0.8}`],
+        [[".tb-box"], `fill:${v("box")};stroke:${v("edge")};stroke-width:1`],
+        [[".tb-final .tb-box"], `stroke:${v("win")};stroke-width:2`],
+        [[".tb-name", ".tb-score", ".tb-title"], `fill:${v("ink")}`],
+        [[".tb-muted", ".tb-round", ".tb-sub"], `fill:${v("muted")}`],
+        [[".tb-won .tb-name", ".tb-won .tb-score"], "font-weight:700"],
+        [[".tb-lost .tb-name", ".tb-lost .tb-score", ".tb-lost .tb-mark"], "opacity:.55"],
+        [[".tb-ring"], `fill:none;stroke:${v("edge")};stroke-width:1`],
+        [[".tb-won .tb-ring"], `stroke:${v("win")};stroke-width:2`],
+        [[".tb-plain"], `fill:${v("plain")}`],
+        [[".tb-initials"], `fill:${v("ink")}`],
+        [[".tb-half"], `fill:${v("ink")}`],
+        [[".tb-gold"], `fill:${v("gold")}`],
+        [[".tb-champ .tb-ring"], `stroke:${v("gold")};stroke-width:3`],
+        [[".tb-champ-label"], `fill:${v("gold")}`],
+        [[".tb-halo"], `paint-order:stroke;stroke:${v("bg")};stroke-width:4px;stroke-linejoin:round`],
+    ];
+    if (withFont)
+        list.push([["text"], `font-family:var(--tb-font, ${FONT})`]);
+    return list;
+}
+const write = (scope, list, before = "") => list.map(([sel, body]) => `${sel.map((x) => `${before}${scope} ${x}`).join(",")}{${body}}`).join("\n");
+/**
+ * The `<style>` text of a drawing. `auto` is the light look and, under `prefers-color-scheme: dark` or a page that says
+ * `data-theme="dark"` on `<html>`, the dark one; `light`, `dark` and `poster` are one look always. Every colour can be
+ * set from the page with a `--tb-*` custom property.
+ */
+export function styleFor(scope, theme) {
+    if (theme === "light")
+        return write(scope, rules(THEMES.light, false, true));
+    if (theme === "dark")
+        return write(scope, rules(THEMES.dark, false, true));
+    if (theme === "poster")
+        return write(scope, rules(THEMES.poster, true, true));
+    const dark = rules(THEMES.dark, false, false);
+    return [
+        write(scope, rules(THEMES.light, false, true)),
+        `@media (prefers-color-scheme: dark){\n${write(scope, dark, ':root:not([data-theme="light"]) ')}\n}`,
+        write(scope, dark, ':root[data-theme="dark"] '),
+    ].join("\n");
+}