@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.5.0

package/dist/pool.labels.js

@@ -0,0 +1,257 @@
+// The data of a race on a pool: who is in each lane (the lane number, the flag, the name, the country's letters), what each swam (the place as a medal, the time, the reaction time, the splits) and the
+// split pace bars in the lanes. Drawn in feet in the frame of a pool lying wide; a pool lying tall turns it with the pool, so that the labels lie along the lanes, and only the numbers in the discs are
+// turned back upright. Nothing here is a rule of the sport: the sizes are ours.
+import { safeColour, safeLogo } from "./colour.js";
+import { el, esc, num } from "./format.js";
+import { feet } from "./pool.js";
+import { STATUS_TEXT, formatTime, pacePer100, splitMetres } from "./pool.race.js";
+import { textOn, ft } from "./surfaces/surface.js";
+import { textWidth } from "./text.js";
+const ROW = feet(2.5);
+const NAME = 2.7;
+const SMALL = 2.0;
+const DISC = 1.75;
+const GAP = 1.1;
+/** The medal each of the first three places wins: gold, silver and bronze, in these colours whatever the look. */
+export const MEDALS = Object.freeze({ 1: "#d9a620", 2: "#aeb6c0", 3: "#b8733a" });
+/** The width of text in feet, with a margin of a sixth: the estimate is for a bold face, and the pages' fonts differ. */
+const tw = (text, size) => textWidth(text) * size * 1.18;
+/** The most splits a plate writes; a longer race has its splits in the pace bars. */
+const MOST_SPLITS = 8;
+/** The pace bar colours, slowest to fastest: a dark to light scale that stays legible on the water and in print (the scale of viridis, reversed in meaning so that bright is fast). */
+const PACE_STOPS = [
+    [68, 1, 84],
+    [59, 82, 139],
+    [33, 145, 140],
+    [94, 201, 98],
+    [253, 231, 37],
+];
+/** The colour of a pace between the field's slowest (0) and fastest (1). */
+export function paceColour(t) {
+    const x = Math.min(1, Math.max(0, t)) * (PACE_STOPS.length - 1);
+    const k = Math.min(PACE_STOPS.length - 2, Math.floor(x));
+    const f = x - k;
+    const c = PACE_STOPS[k].map((v, i) => Math.round(v + (PACE_STOPS[k + 1][i] - v) * f));
+    return `#${c.map((v) => v.toString(16).padStart(2, "0")).join("")}`;
+}
+/** The ink that reads on a colour. */
+const inkFor = (hex) => {
+    const [r, g, b] = [1, 3, 5].map((i) => parseInt(hex.slice(i, i + 2), 16) / 255);
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b > 0.45 ? "#10161c" : "#ffffff";
+};
+function disc(o, cx, cy, text, cls, fill) {
+    const r = DISC;
+    const size = text.length > 2 ? r * 0.95 : r * 1.25;
+    return el("circle", { class: cls, cx, cy, r, fill }) + textOn(o.portrait, cx, cy + size * 0.36, text, { size, anchor: "middle", cls: "ky-pl-dn", weight: 800 });
+}
+function flagMarkup(row, x, cy, w, h) {
+    const logo = safeLogo(row.flag);
+    if (logo === undefined)
+        return "";
+    return el("image", { class: "ky-logo", href: logo, x, y: cy - h / 2, width: w, height: h, preserveAspectRatio: "xMidYMid slice" }) + el("rect", { class: "ky-pl-fb", x, y: cy - h / 2, width: w, height: h, rx: 0.25, fill: "none" });
+}
+/** The plate of a swimmer at the starting end, and its width in feet. */
+function namePlate(plan, o, row, cy, widths, size) {
+    const race = plan.race;
+    if (race === undefined)
+        return "";
+    const show = race.show;
+    const h = ROW * 0.84;
+    const plateW = plateWidth(plan, widths);
+    const x1 = -labelEdge();
+    const x0 = x1 - plateW;
+    let out = el("rect", { class: "ky-pl-pl", x: x0, y: cy - h / 2, width: plateW, height: h, rx: h * 0.18 });
+    const colour = safeColour(row.color);
+    if (colour !== undefined)
+        out += el("rect", { x: x0, y: cy - h / 2, width: 0.7, height: h, fill: colour, rx: 0.3 });
+    let x = x0 + GAP + (colour === undefined ? 0 : 0.7);
+    if (show.flags && widths.flag > 0) {
+        out += flagMarkup(row, x, cy, widths.flag, widths.flag * 0.667);
+        x += widths.flag + GAP;
+    }
+    if (show.names) {
+        out += el("text", { class: "ky-text ky-pl-nm", x, y: cy + size * 0.36, "font-size": size }, esc(row.name));
+        x += widths.name + GAP;
+    }
+    if (widths.abbr > 0) {
+        out += el("text", { class: "ky-text ky-pl-ab", x, y: cy + SMALL * 0.36, "font-size": SMALL }, esc(row.abbr));
+        x += widths.abbr + GAP;
+    }
+    if (widths.seed > 0) {
+        out += el("text", { class: "ky-text ky-pl-ab", x, y: cy + SMALL * 0.36, "font-size": SMALL * 0.9 }, esc(row.seed ?? ""));
+        x += widths.seed + GAP;
+    }
+    out += disc(o, x1 - GAP - DISC, cy, String(row.lane), "ky-pl-ld");
+    return el("g", { class: "ky-pl-row", "data-lane": row.lane }, out);
+}
+/** How far from the pool's end wall the plates stand, in feet: past the blocks. */
+function labelEdge() {
+    return feet(1.6) + 1.2;
+}
+function plateWidth(plan, widths) {
+    const show = plan.race?.show;
+    let w = GAP + DISC * 2 + GAP;
+    if (show?.flags && widths.flag > 0)
+        w += widths.flag + GAP;
+    if (show?.names)
+        w += widths.name + GAP;
+    if (widths.abbr > 0)
+        w += widths.abbr + GAP;
+    if (widths.seed > 0)
+        w += widths.seed + GAP;
+    return w;
+}
+/** The text of a row's splits: the cumulative times at 50, 100... as the scoreboard writes them. */
+const splitsText = (row) => row.splits.filter((s) => Number.isFinite(s)).map(formatTime).join("  ");
+/** The plate of a result at the turning end. */
+function resultPlate(plan, o, row, cy, measure, length) {
+    const race = plan.race;
+    if (race === undefined)
+        return "";
+    const show = race.show;
+    const h = ROW * 0.84;
+    const x0 = length + labelEdge();
+    const plateW = measure.time + measure.extra + 2 * GAP + (show.medals ? DISC * 2 + GAP : 0);
+    let out = el("rect", { class: "ky-pl-pl", x: x0, y: cy - h / 2, width: plateW, height: h, rx: h * 0.18 });
+    let x = x0 + GAP;
+    const place = row.place;
+    if (show.medals && row.status === undefined) {
+        if (place !== undefined) {
+            const colour = MEDALS[place];
+            out += disc(o, x + DISC, cy, String(place), colour === undefined ? "ky-pl-ld" : "ky-pl-mm", colour);
+            if (colour !== undefined)
+                out += el("circle", { class: "ky-pl-mr", cx: x + DISC, cy, r: DISC - 0.35 });
+        }
+        x += DISC * 2 + GAP;
+    }
+    else if (show.medals)
+        x += DISC * 2 + GAP;
+    const time = row.status !== undefined ? STATUS_TEXT[row.status] : (row.timeText ?? "");
+    const two = measure.lines === 2;
+    const topY = two ? cy - ROW * 0.12 : cy;
+    out += el("text", { class: "ky-text ky-pl-tm", x, y: topY + NAME * 0.36, "font-size": NAME }, esc(time));
+    let tail = x + tw(time, NAME) + GAP * 1.6;
+    if (row.record !== undefined) {
+        out += el("text", { class: "ky-text ky-pl-rc", x: tail, y: topY + SMALL * 0.36, "font-size": SMALL * 0.9 }, esc(row.record));
+        tail += tw(row.record, SMALL * 0.9) + GAP * 1.2;
+    }
+    if (show.reaction && row.reaction !== undefined)
+        out += el("text", { class: "ky-text ky-pl-ab", x: tail, y: topY + SMALL * 0.36, "font-size": SMALL * 0.9 }, esc(`RT ${row.reaction.toFixed(2)}`));
+    if (two)
+        out += el("text", { class: "ky-text ky-pl-sp", x, y: cy + ROW * 0.22 + SMALL * 0.3, "font-size": SMALL * 0.9 }, esc(splitsText(row)));
+    return el("g", { class: "ky-pl-row", "data-lane": row.lane }, out);
+}
+/** The pace bars of the race: each split a bar along its share of the lane, in the colour of its pace. */
+function paceBars(plan, o) {
+    const race = plan.race;
+    if (race === undefined || race.pace === null || race.fastest === undefined || race.slowest === undefined)
+        return "";
+    const L = feet(plan.length);
+    const lanes = new Map(plan.lanes.map((lane) => [lane.number, lane]));
+    const span = race.slowest - race.fastest;
+    let out = "";
+    for (const row of race.rows) {
+        const lane = lanes.get(row.lane);
+        if (lane === undefined)
+            continue;
+        const cy = feet(lane.y);
+        const h = ROW * 0.5;
+        row.splits.forEach((cum, i) => {
+            const from = i === 0 ? 0 : row.splits[i - 1];
+            if (!Number.isFinite(cum) || !Number.isFinite(from))
+                return;
+            const metres = splitMetres(i, race.splitEvery, race.distance);
+            const pace = pacePer100(from, cum, metres);
+            const colour = paceColour(span <= 1e-9 ? 0.5 : 1 - (pace - race.fastest) / span);
+            const x0 = ((i * race.splitEvery) / race.distance) * L;
+            const x1 = Math.min(L, x0 + (metres / race.distance) * L);
+            const gap = 0.35;
+            out += el("rect", { class: "ky-pl-pb", x: x0 + gap, y: cy - h / 2, width: Math.max(0.1, x1 - x0 - 2 * gap), height: h, rx: 0.7, fill: colour, "data-pace": num(pace) });
+            if (race.pace?.labels === true) {
+                const text = formatTime(cum - from);
+                const size = Math.min(2.1, ((x1 - x0 - 2 * gap) * 0.9) / Math.max(1, tw(text, 1)), h * 0.5);
+                if (size >= 0.9)
+                    out += el("text", { class: `ky-text ky-pl-pt ky-pl-pt-${inkFor(colour) === "#ffffff" ? "l" : "d"}`, x: (x0 + x1) / 2, y: cy + size * 0.36, "font-size": size, "text-anchor": "middle" }, esc(text));
+            }
+        });
+    }
+    return el("g", { class: ft(o, "pace-bars", "ky-pl-pace") }, out);
+}
+/** The distances above the pool for the pace bars: where each split ends, in metres of the race. */
+function paceAxis(plan) {
+    const race = plan.race;
+    if (race === undefined || race.pace === null)
+        return "";
+    const L = feet(plan.length);
+    let out = "";
+    const count = Math.max(1, Math.round(race.distance / race.splitEvery));
+    for (let i = 0; i <= count; i += 1) {
+        const d = Math.min(race.distance, i * race.splitEvery);
+        const x = (d / race.distance) * L;
+        out += el("text", { class: "ky-text ky-pl-ax", x, y: -feet(0.85), "font-size": 2, "text-anchor": i === 0 ? "start" : i === count ? "end" : "middle" }, `${num(d)} m`);
+        out += el("path", { class: "ky-line ky-pl-tick", d: `M${num(x)} ${num(-feet(0.5))}V${num(-feet(0.1))}`, "stroke-width": 0.25 });
+    }
+    return out;
+}
+/** Everything the data of the race draws. */
+export function raceArt(plan, o) {
+    const race = plan.race;
+    const none = { left: "", right: "", top: "", pace: "", reachLeft: 0, reachRight: 0, reachTop: 0 };
+    if (race === undefined)
+        return none;
+    const show = race.show;
+    const lanes = new Map(plan.lanes.map((lane) => [lane.number, lane]));
+    const length = feet(plan.length);
+    // The widths of the columns: the longest name fitted into a plate at most this wide (the size shrinks for it).
+    const longest = Math.max(0, ...race.rows.map((r) => tw(r.name, NAME)));
+    const nameMax = 44;
+    const size = longest > nameMax ? NAME * (nameMax / longest) : NAME;
+    const widths = {
+        name: show.names ? Math.min(nameMax, Math.max(14, longest)) : 0,
+        abbr: show.names ? Math.max(0, ...race.rows.map((r) => tw(r.abbr, SMALL))) : 0,
+        seed: show.seeds && race.rows.some((r) => r.seed !== undefined) ? Math.max(...race.rows.map((r) => tw(r.seed ?? "", SMALL * 0.9))) : 0,
+        flag: show.flags && race.rows.some((r) => safeLogo(r.flag) !== undefined) ? 4.5 : 0,
+    };
+    let left = "";
+    let reachLeft = 0;
+    if (race.rows.length > 0 && (show.names || show.flags)) {
+        for (const row of race.rows) {
+            const lane = lanes.get(row.lane);
+            if (lane !== undefined)
+                left += namePlate(plan, o, row, feet(lane.y), widths, size);
+        }
+        reachLeft = labelEdge() + plateWidth(plan, widths);
+    }
+    let right = "";
+    let reachRight = 0;
+    if (race.rows.length > 0 && show.results && race.hasResults) {
+        const splits = show.splits && race.rows.some((r) => r.splits.length > 0 && r.splits.length <= MOST_SPLITS);
+        const lines = splits ? 2 : 1;
+        const times = Math.max(...race.rows.map((r) => tw(r.status !== undefined ? STATUS_TEXT[r.status] : (r.timeText ?? ""), NAME)));
+        const extras = Math.max(...race.rows.map((r) => {
+            const head = GAP * 0.6 + (r.record === undefined ? 0 : tw(r.record, SMALL * 0.9) + GAP * 1.2) + (show.reaction && r.reaction !== undefined ? tw(`RT ${r.reaction.toFixed(2)}`, SMALL * 0.9) + GAP : 0);
+            const splitW = splits && r.splits.length <= MOST_SPLITS ? tw(splitsText(r), SMALL * 0.9) - times : 0;
+            return Math.max(head + GAP, splitW);
+        }));
+        const measure = { time: times, extra: Math.max(0, extras), lines };
+        for (const row of race.rows) {
+            const lane = lanes.get(row.lane);
+            if (lane === undefined)
+                continue;
+            const rowSplits = splits && row.splits.length > 0 && row.splits.length <= MOST_SPLITS;
+            right += resultPlate(plan, o, row, feet(lane.y), { ...measure, lines: rowSplits ? 2 : 1 }, length);
+        }
+        reachRight = labelEdge() + measure.time + measure.extra + 2 * GAP + (show.medals ? DISC * 2 + GAP : 0);
+    }
+    let top = "";
+    let reachTop = 0;
+    if (race.event !== undefined) {
+        top += el("text", { class: "ky-text ky-pl-ev", x: -reachLeft, y: race.pace === null ? -feet(1.2) : -feet(2.5), "font-size": 3.1 }, esc(race.event));
+    }
+    const pace = race.pace === null ? "" : paceBars(plan, o);
+    if (race.pace !== null) {
+        top += paceAxis(plan);
+        reachTop = feet(race.event === undefined ? 1.6 : 3.1);
+    }
+    return { left, right, top, pace, reachLeft, reachRight, reachTop };
+}

package/dist/pool.race.d.ts

@@ -0,0 +1,65 @@
+import type { PaceOptions, PoolRace, RaceShow, Swimmer, SwimmerStatus } from "./pool.types.ts";
+/** A time in seconds from a number or from text: `26.12`, `"26.12"`, `"1:46.91"`. `undefined` when it is neither. */
+export declare function parseTime(value: unknown): number | undefined;
+/**
+ * A time in seconds as swimming writes it, to the hundredth: `26.12`, `1:46.91`, `14:31.02`. A time that rounds to the next minute carries into it.
+ * @example
+ * ```ts
+ * import { formatTime } from "@johnmorrisdotca/kyogijo-stadiums/replay";
+ * console.log(formatTime(26.121), formatTime(106.9), formatTime(59.996));
+ * // 26.12 1:46.90 1:00.00
+ * ```
+ */
+export declare function formatTime(seconds: number): string;
+/** One lane of a race as it is drawn. */
+export interface RaceRow {
+    swimmer: Swimmer;
+    lane: number;
+    name: string;
+    abbr: string;
+    flag: string | undefined;
+    color: string | undefined;
+    seed: string | undefined;
+    /** The final time in seconds and as it is written (a time of text that cannot be read is written as it is). */
+    time: number | undefined;
+    timeText: string | undefined;
+    place: number | undefined;
+    reaction: number | undefined;
+    /** The cumulative times at each split, in seconds; `NaN` for one the data lacks. */
+    splits: number[];
+    status: SwimmerStatus | undefined;
+    record: string | undefined;
+}
+/** A race, checked, with what is shown and the pace of the field. */
+export interface RacePlan {
+    event: string | undefined;
+    /** The metres of the race. */
+    distance: number;
+    /** The metres between two splits. */
+    splitEvery: number;
+    rows: RaceRow[];
+    show: Required<RaceShow>;
+    pace: Required<PaceOptions> | null;
+    /** The seconds per 100 m of the fastest and the slowest split of the field, for the colour of the pace bars. */
+    fastest: number | undefined;
+    slowest: number | undefined;
+    /** True when any swimmer has a time, a status or a place. */
+    hasResults: boolean;
+    hasSplits: boolean;
+    hasReaction: boolean;
+}
+/** The seconds per 100 m of the split from `from` to `to` seconds over `metres`. */
+export declare const pacePer100: (from: number, to: number, metres: number) => number;
+/**
+ * Read and check a race for a pool whose lanes are numbered `lanes`, `splitEvery` metres apart by default and `length` metres long.
+ * `lanes` are the pool's lane numbers in the order they lie down the drawing, which is the order the rows are given in. A swimmer with no `time` whose splits reach the whole race has the last split for it.
+ * @throws RangeError for a lane the pool does not have, or two swimmers in one lane. @throws TypeError when `swimmers` is not a list.
+ */
+export declare function racePlan(race: PoolRace, lanes: readonly number[], defaults: {
+    splitEvery: number;
+    length: number;
+}): RacePlan;
+/** The metres of the split with this index (from 0): `every`, except the last, which is whatever is left of the race. */
+export declare function splitMetres(index: number, every: number, distance: number): number;
+/** The status written in place of a time. */
+export declare const STATUS_TEXT: Readonly<Record<SwimmerStatus, string>>;

package/dist/pool.race.js

@@ -0,0 +1,140 @@
+/** A time in seconds from a number or from text: `26.12`, `"26.12"`, `"1:46.91"`. `undefined` when it is neither. */
+export function parseTime(value) {
+    if (typeof value === "number")
+        return Number.isFinite(value) && value >= 0 ? value : undefined;
+    if (typeof value !== "string")
+        return undefined;
+    const text = value.trim();
+    const clock = /^(\d{1,2}):(\d{1,2})(?:[.,](\d{1,3}))?$/.exec(text);
+    if (clock !== null)
+        return Number(clock[1]) * 60 + Number(clock[2]) + (clock[3] === undefined ? 0 : Number(`0.${clock[3]}`));
+    const plain = /^(\d{1,4})(?:[.,](\d{1,3}))?$/.exec(text);
+    return plain === null ? undefined : Number(plain[1]) + (plain[2] === undefined ? 0 : Number(`0.${plain[2]}`));
+}
+/**
+ * A time in seconds as swimming writes it, to the hundredth: `26.12`, `1:46.91`, `14:31.02`. A time that rounds to the next minute carries into it.
+ * @example
+ * ```ts
+ * import { formatTime } from "@johnmorrisdotca/kyogijo-stadiums/replay";
+ * console.log(formatTime(26.121), formatTime(106.9), formatTime(59.996));
+ * // 26.12 1:46.90 1:00.00
+ * ```
+ */
+export function formatTime(seconds) {
+    const hundredths = Math.round(seconds * 100);
+    const minutes = Math.floor(hundredths / 6000);
+    const rest = hundredths - minutes * 6000;
+    const whole = Math.floor(rest / 100);
+    const part = String(rest - whole * 100).padStart(2, "0");
+    return minutes === 0 ? `${whole}.${part}` : `${minutes}:${String(whole).padStart(2, "0")}.${part}`;
+}
+const STATUSES = ["dq", "dns", "dnf"];
+const clean = (text, max) => {
+    if (typeof text !== "string")
+        return undefined;
+    const one = text.replace(/\s+/g, " ").trim();
+    return one === "" ? undefined : one.slice(0, max);
+};
+const SHOW = { names: true, flags: true, results: true, reaction: true, splits: true, medals: true, seeds: true };
+/** The seconds per 100 m of the split from `from` to `to` seconds over `metres`. */
+export const pacePer100 = (from, to, metres) => ((to - from) * 100) / metres;
+/**
+ * Read and check a race for a pool whose lanes are numbered `lanes`, `splitEvery` metres apart by default and `length` metres long.
+ * `lanes` are the pool's lane numbers in the order they lie down the drawing, which is the order the rows are given in. A swimmer with no `time` whose splits reach the whole race has the last split for it.
+ * @throws RangeError for a lane the pool does not have, or two swimmers in one lane. @throws TypeError when `swimmers` is not a list.
+ */
+export function racePlan(race, lanes, defaults) {
+    if (typeof race !== "object" || race === null || !Array.isArray(race.swimmers))
+        throw new TypeError("a race needs swimmers: a list of { lane, name, ... }");
+    const seen = new Set();
+    const rows = [];
+    for (const swimmer of race.swimmers) {
+        if (typeof swimmer !== "object" || swimmer === null)
+            throw new TypeError("a swimmer is { lane, name, ... }");
+        const lane = swimmer.lane;
+        if (!Number.isInteger(lane) || !lanes.includes(lane))
+            throw new RangeError(`This pool has no lane ${String(lane)}: its lanes are ${Math.min(...lanes)} to ${Math.max(...lanes)}`);
+        if (seen.has(lane))
+            throw new RangeError(`Lane ${lane} has two swimmers`);
+        seen.add(lane);
+        const timeText = typeof swimmer.time === "number" ? (Number.isFinite(swimmer.time) ? formatTime(swimmer.time) : undefined) : clean(swimmer.time, 12);
+        const time = parseTime(swimmer.time);
+        const splits = Array.isArray(swimmer.splits) ? swimmer.splits.map((value) => parseTime(value) ?? Number.NaN) : [];
+        rows.push({
+            swimmer,
+            lane,
+            name: clean(swimmer.name, 40) ?? "",
+            abbr: (clean(swimmer.abbr, 5) ?? "").toLocaleUpperCase("en"),
+            flag: typeof swimmer.flag === "string" ? swimmer.flag : undefined,
+            color: typeof swimmer.color === "string" ? swimmer.color : undefined,
+            seed: typeof swimmer.seed === "number" ? (Number.isFinite(swimmer.seed) ? formatTime(swimmer.seed) : undefined) : clean(swimmer.seed, 12),
+            time,
+            timeText: time !== undefined ? formatTime(time) : timeText,
+            place: Number.isInteger(swimmer.place) && swimmer.place > 0 ? swimmer.place : undefined,
+            reaction: typeof swimmer.reaction === "number" && Number.isFinite(swimmer.reaction) && swimmer.reaction >= 0 ? swimmer.reaction : undefined,
+            splits,
+            status: STATUSES.includes(swimmer.status) ? swimmer.status : undefined,
+            record: clean(swimmer.record, 6)?.toLocaleUpperCase("en"),
+        });
+    }
+    // The rows run down the page in the order of the lanes as the pool is drawn.
+    rows.sort((a, b) => lanes.indexOf(a.lane) - lanes.indexOf(b.lane));
+    const every = Number.isFinite(race.splitEvery) && race.splitEvery > 0 ? race.splitEvery : defaults.splitEvery;
+    const most = Math.max(0, ...rows.map((r) => r.splits.length));
+    const distance = Number.isFinite(race.distance) && race.distance > 0 ? race.distance : most > 0 ? most * every : defaults.length;
+    // The last split is the time of a swimmer whose splits reach the end of the race.
+    for (const r of rows) {
+        if (r.time !== undefined || r.status !== undefined || r.splits.length === 0)
+            continue;
+        const last = r.splits[r.splits.length - 1];
+        if (Number.isFinite(last) && r.splits.length * every >= distance - 1e-6) {
+            r.time = last;
+            r.timeText = formatTime(last);
+        }
+    }
+    // Places from the times, when no one has been given one.
+    if (rows.every((r) => r.place === undefined)) {
+        const timed = rows.filter((r) => r.time !== undefined && r.status === undefined).sort((a, b) => a.time - b.time);
+        let place = 0;
+        let last;
+        timed.forEach((r, i) => {
+            if (r.time !== last)
+                place = i + 1;
+            last = r.time;
+            r.place = place;
+        });
+    }
+    const hasResults = rows.some((r) => r.timeText !== undefined || r.status !== undefined || r.place !== undefined);
+    // The entry times are for a start list: once there are results they are left out, unless the race asks for them.
+    const show = { ...SHOW, seeds: !hasResults, ...Object.fromEntries(Object.entries(race.show ?? {}).filter(([, value]) => typeof value === "boolean")) };
+    const pace = race.pace === undefined || race.pace === false ? null : { labels: race.pace === true || race.pace.labels !== false };
+    // The pace of each split: from the one before it (0 at the start) over the metres between them, the last split over what is left of the race.
+    const paces = [];
+    for (const r of rows) {
+        r.splits.forEach((cum, i) => {
+            const from = i === 0 ? 0 : r.splits[i - 1];
+            if (Number.isFinite(cum) && Number.isFinite(from))
+                paces.push(pacePer100(from, cum, splitMetres(i, every, distance)));
+        });
+    }
+    return {
+        event: clean(race.event, 80),
+        distance,
+        splitEvery: every,
+        rows,
+        show,
+        pace,
+        fastest: paces.length === 0 ? undefined : Math.min(...paces),
+        slowest: paces.length === 0 ? undefined : Math.max(...paces),
+        hasResults,
+        hasSplits: most > 0,
+        hasReaction: rows.some((r) => r.reaction !== undefined),
+    };
+}
+/** The metres of the split with this index (from 0): `every`, except the last, which is whatever is left of the race. */
+export function splitMetres(index, every, distance) {
+    const start = index * every;
+    return Math.max(1e-6, Math.min(every, distance - start));
+}
+/** The status written in place of a time. */
+export const STATUS_TEXT = Object.freeze({ dq: "DQ", dns: "DNS", dnf: "DNF" });

package/dist/pool.replay.d.ts

@@ -0,0 +1,46 @@
+import { type RaceRow } from "./pool.race.ts";
+import type { ReplayEvent, ReplayTimeline } from "./replay.types.ts";
+import type { Language, SurfaceOptions } from "./types.ts";
+/** What a race replay is made with. */
+export interface RaceReplayOptions {
+    /** Frames a second. 10 by default. */
+    fps?: number;
+    /** Seconds of waiting before the start signal and of staying on after the last touch. 1.5 and 3 by default. */
+    lead?: number;
+    tail?: number;
+    /** The language of the events' words. English by default. */
+    language?: Language;
+    /** The reaction time of a swimmer that has none, in seconds. 0.7 by default. */
+    reaction?: number;
+    /** How far behind the wall a swimmer on the block stands, in metres. 0.4 by default. */
+    block?: number;
+}
+/** The marks of a swimmer's progress: the seconds after the start signal at which the swimmer has swum each distance, from the splits (and the final time). */
+export interface Progress {
+    /** Distance in metres against the seconds after the signal; the first point is the reaction time at 0 m. */
+    points: [number, number][];
+    /** Whether the swimmer is a swimmer in the water at all (a swimmer who did not start stays on the block). */
+    swims: boolean;
+}
+/** The progress of one row over a race of `distance` metres with a split every `every` metres. */
+export declare function progressOf(row: RaceRow, distance: number, every: number, reaction: number): Progress;
+/** The metres a swimmer has swum `t` seconds after the signal, by straight lines between the points of progress; before the reaction it is 0, after the last it stays. */
+export declare function distanceAt(progress: Progress, t: number): number;
+/** The place along the pool, in metres from the starting wall, of a swimmer who has swum `d` metres in a pool of `length`: down the first length, back the next. */
+export declare function alongPool(d: number, length: number): number;
+/**
+ * The replay of a race by lane. Give the options of a swimming drawing (`{ pool: { race } }`, with a `course` and `lanes` if they are not the 50 m pool's of eight): each swimmer with splits is played back from them.
+ * The timeline is in the pool's frame (`from: "swimming"`) in metres; its events are the turns at the walls and the finish, each with the swimmer's name and, at the finish, the time.
+ * @throws TypeError when the options have no race, RangeError for a race with no swimmer that has splits or a time.
+ * @example
+ * ```ts
+ * import { raceTimeline, drawFrame } from "@johnmorrisdotca/kyogijo-stadiums/replay";
+ * const pool = { race: { distance: 100, swimmers: [{ lane: 4, name: "A. Swimmer", splits: [26, 54.2] }, { lane: 5, name: "B. Swimmer", splits: [26.4, 55] }] } };
+ * const timeline = raceTimeline({ pool });
+ * console.log(timeline.frames.length > 100, timeline.events.map((e) => e.kind).join(), drawFrame({ sport: "swimming", pool }, timeline, 20).startsWith("<svg"));
+ * // true start,turn,turn,finish,finish true
+ * ```
+ */
+export declare function raceTimeline(options: Pick<SurfaceOptions, "pool">, replay?: RaceReplayOptions): ReplayTimeline & {
+    events: ReplayEvent[];
+};

package/dist/pool.replay.js

@@ -0,0 +1,127 @@
+// A race replay by lane: the swimmers of a race move down their lanes and back as their splits say, as a timeline of the package's replay (`drawFrame`, `mountKyogijo(...).replay`, `<kyogijo-field>`). Each
+// swimmer is a mark with the lane's number on it, in the frame of the pool (`swimming`: metres from the middle of the water, x towards the turning end, y towards the top of the drawing, so that lane 1 is below
+// lane 8). Between two splits a swimmer goes at the speed of the split, in a straight line; before the reaction time the swimmer is on the block. The wall is touched at the turns, and the field's order is the order
+// of the marks. Nothing here is a model of swimming: it is the splits the caller has, played back.
+import { swimPlan } from "./pool.js";
+import { formatTime } from "./pool.race.js";
+import { KYOGIJO_STRINGS } from "./strings.js";
+const finite = (value) => Number.isFinite(value);
+/** The progress of one row over a race of `distance` metres with a split every `every` metres. */
+export function progressOf(row, distance, every, reaction) {
+    const start = row.reaction ?? reaction;
+    if (row.status === "dns")
+        return { points: [[0, 0]], swims: false };
+    const points = [[start, 0]];
+    let last = start;
+    row.splits.forEach((cum, i) => {
+        if (!finite(cum))
+            return;
+        const at = Math.min(distance, (i + 1) * every);
+        if (cum <= last)
+            return;
+        // A split is the distance the swimmer has swum when the clock reads it: the last one is the whole race.
+        points.push([cum, i === row.splits.length - 1 && row.time !== undefined && Math.abs(cum - row.time) < 1e-6 ? distance : at]);
+        last = cum;
+    });
+    const end = points[points.length - 1];
+    // A time without all its splits: the rest is swum at one speed up to it.
+    if (row.time !== undefined && row.time > end[0] && row.status !== "dnf" && end[1] < distance)
+        points.push([row.time, distance]);
+    return { points, swims: points.length > 1 };
+}
+/** The metres a swimmer has swum `t` seconds after the signal, by straight lines between the points of progress; before the reaction it is 0, after the last it stays. */
+export function distanceAt(progress, t) {
+    const p = progress.points;
+    if (t <= p[0][0])
+        return 0;
+    for (let i = 1; i < p.length; i += 1) {
+        if (t <= p[i][0]) {
+            const [t0, d0] = p[i - 1];
+            const [t1, d1] = p[i];
+            return d0 + ((t - t0) / (t1 - t0)) * (d1 - d0);
+        }
+    }
+    return p[p.length - 1][1];
+}
+/** The place along the pool, in metres from the starting wall, of a swimmer who has swum `d` metres in a pool of `length`: down the first length, back the next. */
+export function alongPool(d, length) {
+    const lap = Math.floor(d / length + 1e-9);
+    const rest = d - lap * length;
+    return lap % 2 === 0 ? rest : length - rest;
+}
+/**
+ * The seconds after the signal at which a swimmer has swum `d` metres: the inverse of `distanceAt` over the progress, for the turns.
+ */
+function timeAt(progress, d) {
+    const p = progress.points;
+    for (let i = 1; i < p.length; i += 1) {
+        if (d <= p[i][1] + 1e-9 && p[i][1] > p[i - 1][1]) {
+            const [t0, d0] = p[i - 1];
+            const [t1, d1] = p[i];
+            return t0 + ((d - d0) / (d1 - d0)) * (t1 - t0);
+        }
+    }
+    return undefined;
+}
+/**
+ * The replay of a race by lane. Give the options of a swimming drawing (`{ pool: { race } }`, with a `course` and `lanes` if they are not the 50 m pool's of eight): each swimmer with splits is played back from them.
+ * The timeline is in the pool's frame (`from: "swimming"`) in metres; its events are the turns at the walls and the finish, each with the swimmer's name and, at the finish, the time.
+ * @throws TypeError when the options have no race, RangeError for a race with no swimmer that has splits or a time.
+ * @example
+ * ```ts
+ * import { raceTimeline, drawFrame } from "@johnmorrisdotca/kyogijo-stadiums/replay";
+ * const pool = { race: { distance: 100, swimmers: [{ lane: 4, name: "A. Swimmer", splits: [26, 54.2] }, { lane: 5, name: "B. Swimmer", splits: [26.4, 55] }] } };
+ * const timeline = raceTimeline({ pool });
+ * console.log(timeline.frames.length > 100, timeline.events.map((e) => e.kind).join(), drawFrame({ sport: "swimming", pool }, timeline, 20).startsWith("<svg"));
+ * // true start,turn,turn,finish,finish true
+ * ```
+ */
+export function raceTimeline(options, replay = {}) {
+    const plan = swimPlan({ sport: "swimming", pool: options.pool });
+    const race = plan.race;
+    if (race === undefined)
+        throw new TypeError("a race replay needs a race: { pool: { race: { swimmers: [...] } } }");
+    const fps = typeof replay.fps === "number" && replay.fps >= 1 && replay.fps <= 60 ? replay.fps : 10;
+    const lead = typeof replay.lead === "number" && replay.lead >= 0 ? replay.lead : 1.5;
+    const tail = typeof replay.tail === "number" && replay.tail >= 0 ? replay.tail : 3;
+    const reaction = typeof replay.reaction === "number" && replay.reaction >= 0 ? replay.reaction : 0.7;
+    const block = typeof replay.block === "number" && replay.block >= 0 ? replay.block : 0.4;
+    const words = KYOGIJO_STRINGS[replay.language === "ja" ? "ja" : "en"].pool.chart;
+    const lanes = new Map(plan.lanes.map((lane) => [lane.number, lane]));
+    const L = plan.length;
+    const rows = race.rows.map((row) => ({ row, progress: progressOf(row, race.distance, race.splitEvery, reaction) }));
+    if (!rows.some((r) => r.progress.swims))
+        throw new RangeError("a race replay needs a swimmer with splits or a time");
+    const end = Math.max(...rows.map((r) => r.progress.points[r.progress.points.length - 1][0]));
+    const total = lead + end + tail;
+    const count = Math.ceil(total * fps);
+    const objectAt = (r, t) => {
+        const lane = lanes.get(r.row.lane);
+        const d = distanceAt(r.progress, t - lead);
+        const onBlock = t - lead < r.progress.points[0][0];
+        const x = onBlock ? -block : alongPool(d, L);
+        return { id: `lane-${r.row.lane}`, team: "home", x: Math.round((x - L / 2) * 1000) / 1000, y: Math.round((plan.width / 2 - lane.y) * 1000) / 1000, label: r.row.name, number: r.row.lane };
+    };
+    const frames = [];
+    for (let i = 0; i <= count; i += 1) {
+        const t = Math.round((i / fps) * 1000) / 1000;
+        frames.push({ t, objects: rows.map((r) => objectAt(r, t)) });
+    }
+    const events = [{ t: lead, kind: "start", label: words.start }];
+    for (const r of rows) {
+        if (!r.progress.swims)
+            continue;
+        const id = `lane-${r.row.lane}`;
+        // A turn at each wall the swimmer touches before the finish.
+        for (let wall = 1; wall * L < race.distance - 1e-6; wall += 1) {
+            const at = timeAt(r.progress, wall * L);
+            if (at !== undefined)
+                events.push({ t: Math.round((lead + at) * 1000) / 1000, kind: "turn", by: id, label: `${r.row.name}, ${words.turn.toLowerCase()}` });
+        }
+        const last = r.progress.points[r.progress.points.length - 1];
+        if (last[1] >= race.distance - 1e-6)
+            events.push({ t: Math.round((lead + last[0]) * 1000) / 1000, kind: "finish", by: id, label: `${r.row.name}, ${words.finish.toLowerCase()} ${r.row.timeText ?? formatTime(last[0])}` });
+    }
+    events.sort((a, b) => a.t - b.t);
+    return { frames, events, from: "swimming", units: "m" };
+}

package/dist/pool.section.d.ts

@@ -0,0 +1,13 @@
+import type { SwimPlan } from "./pool.ts";
+import { type BuildOptions } from "./surfaces/surface.ts";
+/** The section: its markup and how far it reaches below `y0` (feet). */
+export interface Section {
+    markup: string;
+    height: number;
+    /** The id of the gradient its water uses, to define in the drawing's defs. */
+    defs: string;
+}
+/**
+ * The section of a pool whose water's surface is at `top` feet (in the drawing's frame, below the plan), for a pool that is `plan.length` long, aligned with the plan along x.
+ */
+export declare function sectionOf(plan: SwimPlan, o: Pick<BuildOptions, "portrait" | "features" | "exact" | "detail" | "id">, top: number): Section;