@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.5.0

package/dist/pool.section.js

@@ -0,0 +1,83 @@
+// A side section of a swimming pool, drawn under its plan on the same scale along the pool: the water and its depth, the starting blocks and touch panels at the walls, the backstroke flags 5 m from each end, the
+// false start rope 15 m from the starting end, a lane rope at the surface, and the least depth the rules ask for (1.35 m from 1 to 6 m from a wall with blocks, then the pool's own). Its height is exaggerated
+// (`section.exaggerate`, 2.5 by default): a pool 50 m long and 2.5 m deep would be a sliver otherwise. Written in feet; the words are upright whatever the pool does.
+import { el, num } from "./format.js";
+import { feet } from "./pool.js";
+import { SWIMMING } from "./pool.figures.js";
+import { textOn, ft } from "./surfaces/surface.js";
+/**
+ * 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 function sectionOf(plan, o, top) {
+    const sec = plan.section;
+    if (sec === undefined)
+        return { markup: "", height: 0, defs: "" };
+    const E = sec.exaggerate;
+    const L = feet(plan.length);
+    const v = (metres) => feet(metres) * E;
+    const depth = plan.depth;
+    const surfaceY = top + v(SWIMMING.flags.height) + 4;
+    const floorY = surfaceY + v(depth);
+    const full = o.detail === "full";
+    const turned = o.portrait;
+    const gradient = `${o.id}-wd`;
+    let out = "";
+    const defs = plan.look === "flat" ? "" : el("linearGradient", { id: gradient, x1: 0, y1: 0, x2: 0, y2: 1 }, el("stop", { offset: 0, class: "ky-pl-sa" }) + el("stop", { offset: 1, class: "ky-pl-sc" }));
+    // The ground under the section is the deck's colour; the water body between the walls.
+    out += el("rect", { class: ft(o, "water", "ky-surface"), x: 0, y: surfaceY, width: L, height: floorY - surfaceY });
+    if (plan.look !== "flat")
+        out += el("rect", { class: "ky-pl-wg", x: 0, y: surfaceY, width: L, height: floorY - surfaceY, fill: `url(#${gradient})` });
+    // The walls and the floor of the pool as a section: a thick line, with the deck level at the surface.
+    const wall = 1.1;
+    out += el("path", { class: ft(o, "gutter", "ky-pl-sw"), d: `M${num(-wall)} ${num(surfaceY - 0.6)}H0V${num(floorY)}H${num(L)}V${num(surfaceY - 0.6)}H${num(L + wall)}V${num(floorY + wall)}H${num(-wall)}Z` });
+    // The least depth the rules ask for.
+    const least = feet(SWIMMING.depth.atBlocks) * E;
+    const blocksFrom = feet(SWIMMING.depth.blocksFrom);
+    const blocksTo = feet(SWIMMING.depth.blocksTo);
+    if (full) {
+        const y = surfaceY + least;
+        const d = `M${num(blocksFrom)} ${num(y)}H${num(blocksTo)}M${num(L - blocksTo)} ${num(y)}H${num(L - blocksFrom)}`;
+        out += el("path", { class: "ky-line ky-pl-lm", d, "stroke-width": 0.35, "stroke-dasharray": "1.4 1", fill: "none" });
+        out += textOn(turned, (blocksFrom + blocksTo) / 2, y - 0.9, `${SWIMMING.depth.atBlocks} m`, { size: 2, anchor: "middle", cls: "ky-pl-sx" });
+    }
+    // Blocks (0.5 to 0.75 m above the water) and touch panels (0.3 m above, 0.6 m below).
+    const blockH = v(SWIMMING.block.height);
+    const blockL = feet(SWIMMING.block.length) * 1.4;
+    if (plan.blocks) {
+        out += el("path", { class: "ky-pl-bk", d: `M${num(-blockL)} ${num(surfaceY)}V${num(surfaceY - blockH)}H${num(-blockL * 0.15)}L0 ${num(surfaceY - blockH * 0.8)}V${num(surfaceY)}ZM${num(L + blockL)} ${num(surfaceY)}V${num(surfaceY - blockH)}H${num(L + blockL * 0.15)}L${num(L)} ${num(surfaceY - blockH * 0.8)}V${num(surfaceY)}Z` });
+    }
+    if (plan.pads) {
+        const above = v(SWIMMING.pad.above);
+        const below = v(SWIMMING.pad.below);
+        const w = 0.9;
+        out += el("path", { class: "ky-pl-pad", d: `M0 ${num(surfaceY - above)}h${num(w)}V${num(surfaceY + below)}H0ZM${num(L)} ${num(surfaceY - above)}h${num(-w)}V${num(surfaceY + below)}H${num(L)}Z`, stroke: "none" });
+    }
+    // The backstroke flags: a rope 1.8 m up between two standards, with its flags, 5 m from each wall.
+    if (plan.flags) {
+        for (const x of [SWIMMING.flags.at, plan.length - SWIMMING.flags.at]) {
+            const px = feet(x);
+            const h = v(SWIMMING.flags.height);
+            out += el("path", { class: "ky-line ky-pl-pole", d: `M${num(px)} ${num(surfaceY)}V${num(surfaceY - h)}`, "stroke-width": 0.4, fill: "none" });
+            // Seen along the pool the rope is a point, and the flags hang from it in a row: one pennant is what is seen.
+            if (full)
+                out += el("path", { class: "ky-pl-fp", d: `M${num(px - 1.3)} ${num(surfaceY - h)}h2.6l${num(-1.3)} 3.1Z` });
+            out += textOn(turned, px, surfaceY - h - 1.4, `${SWIMMING.flags.at} m`, { size: 2, anchor: "middle", cls: "ky-pl-sx" });
+        }
+    }
+    // The false start rope: 1.2 m or more above the water, 15 m from the starting end.
+    if (plan.falseStart) {
+        const px = feet(SWIMMING.falseStart.at);
+        const h = v(SWIMMING.falseStart.height);
+        out += el("path", { class: "ky-line ky-pl-pole", d: `M${num(px)} ${num(surfaceY)}V${num(surfaceY - h)}`, "stroke-width": 0.4, fill: "none" });
+        out += el("circle", { class: "ky-pl-fs", cx: px, cy: surfaceY - h, r: 0.8 });
+        out += textOn(turned, px, surfaceY - h - 1.4, `${SWIMMING.falseStart.at} m`, { size: 2, anchor: "middle", cls: "ky-pl-sx" });
+    }
+    // A lane rope at the surface: its floats half under the water.
+    out += el("path", { class: ft(o, ["lane-ropes", "rope-blue"], "ky-pl-r ky-pl-r-blue"), d: `M0 ${num(surfaceY)}H${num(L)}`, "stroke-width": 1.7, "stroke-dasharray": "0 1.45", fill: "none" });
+    // The lane marking on the floor, and the depth.
+    out += el("path", { class: "ky-line", d: `M${num(feet(SWIMMING.laneLine.endGap))} ${num(floorY - 0.3)}H${num(L - feet(SWIMMING.laneLine.endGap))}`, "stroke-width": 0.5, fill: "none" });
+    const dx = -wall - 2.2;
+    out += el("path", { class: "ky-line ky-pl-dm", d: `M${num(dx)} ${num(surfaceY)}V${num(floorY)}M${num(dx - 0.9)} ${num(surfaceY)}H${num(dx + 0.9)}M${num(dx - 0.9)} ${num(floorY)}H${num(dx + 0.9)}`, "stroke-width": 0.3, fill: "none" });
+    out += textOn(turned, dx - 1.4, (surfaceY + floorY) / 2 + 0.7, `${num(depth)} m`, { size: 2.2, anchor: "end", cls: "ky-pl-sx" });
+    return { markup: el("g", { class: "ky-pl-section" }, out), height: floorY + wall - top, defs };
+}

package/dist/pool.style.d.ts

@@ -0,0 +1,20 @@
+import type { DeckLook, PoolLook, PoolSport } from "./pool.types.ts";
+/** What a drawing of a pool has in it, so that its stylesheet carries only what it needs. */
+export interface PoolStyleUse {
+    sport: PoolSport;
+    look: PoolLook;
+    deck: DeckLook;
+    /** The lanes of a race are drawn: the plates, the medals, the pace bars. */
+    race: boolean;
+    /** A side section is drawn. */
+    section: boolean;
+    /** Several pools in one hall: the names of the pools. */
+    hall?: boolean;
+}
+/**
+ * The stylesheet of a pool drawing, with only what it uses: the palette for its sport, the rules of the ropes, its sport's own, and, if it has them, the light on the water, the tiles, the labels of a race and a
+ * section.
+ */
+export declare function poolStyle(use: PoolStyleUse): string;
+/** The rules of every pool, for a page that draws with `style: "none"` and supplies the stylesheet itself. */
+export declare const KYOGIJO_POOL_STYLE: string;

package/dist/pool.style.js

@@ -0,0 +1,169 @@
+// The stylesheet of the pools: the colours of the water, the deck, the lane ropes and the fixtures, in light and in dark, at no weight (`:where()`) so that a look, a page's rule and the options' `colors` all win,
+// and the rule of each class a pool is drawn with. The rules of the sports do not set a colour for a deck or the water (they do for the lane ropes: green, blue, yellow, and red floats near the walls, which are
+// kept in every look). These are our colours. A drawing carries only the rules its pool uses: the sport's, the light on the water if it has it, the labels of a race if there is one; a page that draws with
+// `style: "none"` takes `KYOGIJO_POOL_STYLE`, which has them all.
+import { POOL_SPORTS } from "./pool.js";
+/** The colours that change between light and dark, by custom property; the rest do not change. */
+const LIGHT = {
+    "--ky-surface": "#3fb4e6",
+    "--ky-surface-alt": "#2a9bd2",
+    "--ky-apron": "#e3e1d9",
+    "--ky-boards": "#f7f6f1",
+    "--ky-line": "#0c3a5c",
+    "--ky-plate": "rgba(14,24,32,.88)",
+    "--ky-pd": "#f3d32c",
+    "--ky-pk": "#454f59",
+    "--ky-pe": "#16212a",
+    "--ky-ps": "#39424a",
+    "--ky-pc": "#cdd2d7",
+    "--ky-pw": "#fbfcfd",
+};
+const DARK = {
+    "--ky-surface": "#1d7aa8",
+    "--ky-surface-alt": "#176b97",
+    "--ky-apron": "#1f252a",
+    "--ky-boards": "#3a434b",
+    "--ky-line": "#031118",
+    "--ky-plate": "rgba(0,0,0,.84)",
+    "--ky-pd": "#dcc23a",
+    "--ky-pk": "#6a7683",
+    "--ky-pe": "#05090c",
+    "--ky-ps": "#8793a0",
+    "--ky-pc": "#66727d",
+    "--ky-pw": "#e9eef2",
+};
+/** The colours that are the same in both modes: the lane ropes and the fixtures' accents (the rules fix the ropes' colours, and a look may change them). */
+const SAME = {
+    "--ky-pg": "#1fa35a",
+    "--ky-pb": "#1b66d3",
+    "--ky-py": "#f4c514",
+    "--ky-pr": "#e0392f",
+    "--ky-pf": "#ff7a1a",
+    "--ky-fa": "#e0392f",
+    "--ky-fb": "#fff",
+    "--ky-pbd": "#e8691d",
+    "--ky-layer-home": "#ffd23f",
+    "--ky-layer-away": "#ff7a59",
+    "--ky-layer-ink": "#071a2b",
+};
+/** The light on the water and the tiles, which a pool has only in the looks that draw them. */
+const LIGHT_PAINT = { "--ky-pla": "rgba(255,255,255,.34)", "--ky-ptl": "rgba(255,255,255,.2)", "--ky-pda": "rgba(120,112,98,.06)", "--ky-pdj": "rgba(90,84,72,.16)" };
+const DARK_PAINT = { "--ky-pla": "rgba(190,235,255,.3)", "--ky-ptl": "rgba(190,235,255,.14)", "--ky-pda": "rgba(255,255,255,.04)", "--ky-pdj": "rgba(255,255,255,.1)" };
+const declarations = (table) => Object.entries(table)
+    .map(([k, v]) => `${k}:${v}`)
+    .join(";");
+const RULES = {
+    common: [
+        ".kyogijo .ky-pl-r{fill:none;stroke-linecap:round}",
+        ".kyogijo .ky-pl-r-green{stroke:var(--ky-pg)}",
+        ".kyogijo .ky-pl-r-blue{stroke:var(--ky-pb)}",
+        ".kyogijo .ky-pl-r-yellow{stroke:var(--ky-py)}",
+        ".kyogijo .ky-pl-r-red{stroke:var(--ky-pr)}",
+        ".kyogijo .ky-pl-r-white{stroke:var(--ky-pw)}",
+    ],
+    light: [".kyogijo .ky-pl-sa{stop-color:var(--ky-surface)}", ".kyogijo .ky-pl-sb,.kyogijo .ky-pl-sc{stop-color:var(--ky-surface-alt)}", ".kyogijo .ky-pl-lt{fill:var(--ky-pla);fill-opacity:.08;stroke:var(--ky-pla);stroke-width:.2;stroke-linejoin:round}"],
+    floor: [".kyogijo .ky-pl-ft{fill:none;stroke:var(--ky-ptl);stroke-width:.14}"],
+    deck: [".kyogijo .ky-pl-da{fill:var(--ky-pda)}", ".kyogijo .ky-pl-dt{fill:none;stroke:var(--ky-pdj);stroke-width:.12}"],
+    swimming: [
+        ".kyogijo .ky-pl-pad{fill:var(--ky-pd);stroke:var(--ky-pe);stroke-width:.14;stroke-linejoin:round}",
+        ".kyogijo .ky-pl-bk{fill:var(--ky-pk);stroke:var(--ky-pe);stroke-width:.12;stroke-linejoin:round}",
+        ".kyogijo .ky-pl-bn{fill:#fff}",
+        ".kyogijo .ky-pl-fa{stroke:var(--ky-fa);fill:none}",
+        ".kyogijo .ky-pl-fb2{stroke:var(--ky-fb);fill:none}",
+        ".kyogijo .ky-pl-fs{stroke:var(--ky-pf);fill:none}",
+        ".kyogijo .ky-pl-st{fill:var(--ky-ps);stroke:var(--ky-pe);stroke-width:.1}",
+    ],
+    race: [
+        ".kyogijo .ky-pl-pl{fill:var(--ky-plate)}",
+        ".kyogijo .ky-pl-nm,.kyogijo .ky-pl-tm{fill:var(--ky-plate-ink);font-weight:800}",
+        ".kyogijo .ky-pl-ab,.kyogijo .ky-pl-sp,.kyogijo .ky-pl-rc{fill:var(--ky-plate-ink);opacity:.78;font-weight:700}",
+        ".kyogijo .ky-pl-ld{fill:var(--ky-plate-ink)}",
+        ".kyogijo .ky-pl-dn{fill:#10161c;text-anchor:middle}",
+        ".kyogijo .ky-pl-mm{stroke:rgba(0,0,0,.35);stroke-width:.2}",
+        ".kyogijo .ky-pl-mr{fill:none;stroke:rgba(255,255,255,.55);stroke-width:.25}",
+        ".kyogijo .ky-pl-fb{stroke:rgba(255,255,255,.55);stroke-width:.18}",
+        ".kyogijo .ky-pl-pb{stroke:rgba(0,0,0,.35);stroke-width:.18}",
+        ".kyogijo .ky-pl-pt-d{fill:#10161c}",
+        ".kyogijo .ky-pl-pt-l{fill:#fff}",
+        ".kyogijo .ky-pl-ev{font-weight:800}",
+        ".kyogijo .ky-pl-ax{opacity:.85;font-weight:700}",
+        ".kyogijo .ky-pl-tick{opacity:.7}",
+    ],
+    section: [
+        ".kyogijo .ky-pl-sw{fill:var(--ky-boards);stroke:var(--ky-pe);stroke-width:.2;stroke-linejoin:round}",
+        ".kyogijo .ky-pl-lm,.kyogijo .ky-pl-dm{stroke:var(--ky-ink)}",
+        ".kyogijo .ky-pl-sx{font-weight:700}",
+        ".kyogijo .ky-pl-pole{stroke:var(--ky-ps)}",
+        ".kyogijo .ky-pl-fp{fill:var(--ky-fa);stroke:var(--ky-pe);stroke-width:.12;stroke-linejoin:round}",
+    ],
+    waterpolo: [
+        ".kyogijo .ky-pl-rp{stroke:var(--ky-pe);stroke-width:.1}",
+        ".kyogijo .ky-pl-rp-red{fill:var(--ky-pr)}",
+        ".kyogijo .ky-pl-rp-yellow{fill:var(--ky-py)}",
+        ".kyogijo .ky-pl-rp-green{fill:var(--ky-pg)}",
+        ".kyogijo .ky-pl-wl{fill:none}",
+        ".kyogijo .ky-pl-wl-white{stroke:var(--ky-pw)}",
+        ".kyogijo .ky-pl-wl-red{stroke:var(--ky-pr)}",
+        ".kyogijo .ky-pl-wl-yellow{stroke:var(--ky-py)}",
+        ".kyogijo .ky-pl-ra{fill:var(--ky-pr);fill-opacity:.4;stroke:var(--ky-pr);stroke-width:.2}",
+        ".kyogijo .ky-pl-gn{stroke:var(--ky-pw);opacity:.85}",
+        ".kyogijo .ky-pl-gb{stroke:var(--ky-pw)}",
+        ".kyogijo .ky-pl-gp{fill:var(--ky-pw);stroke:var(--ky-pe);stroke-width:.12}",
+        ".kyogijo .ky-pl-tb{fill:var(--ky-pk);stroke:var(--ky-pe);stroke-width:.14}",
+        ".kyogijo .ky-pl-sa-l{fill:var(--ky-left)}",
+        ".kyogijo .ky-pl-sa-r{fill:var(--ky-right)}",
+    ],
+    diving: [
+        ".kyogijo .ky-pl-sd{fill:var(--ky-boards);stroke:var(--ky-pe);stroke-width:.14}",
+        ".kyogijo .ky-pl-pf{fill:var(--ky-pc);stroke:var(--ky-pe);stroke-width:.14}",
+        ".kyogijo .ky-pl-spb{fill:var(--ky-pbd);stroke:var(--ky-pe);stroke-width:.12}",
+        ".kyogijo .ky-pl-fe{stroke:var(--ky-pe)}",
+        ".kyogijo .ky-pl-pm{fill:var(--ky-pr);stroke:var(--ky-pe);stroke-width:.08}",
+        ".kyogijo .ky-pl-bt{fill:var(--ky-pe);text-anchor:middle}",
+        ".kyogijo .ky-pl-bu{fill:var(--ky-ink)}",
+    ],
+    artisticswimming: [
+        ".kyogijo .ky-pl-dp{fill:#06223c;fill-opacity:.22}",
+        ".kyogijo .ky-pl-dpl{stroke:var(--ky-line)}",
+        ".kyogijo .ky-pl-jp,.kyogijo .ky-pl-sp2{fill:var(--ky-pk);stroke:var(--ky-pe);stroke-width:.14}",
+        ".kyogijo .ky-pl-ch{fill:var(--ky-pw)}",
+    ],
+    hall: [".kyogijo .ky-pl-vn{fill:var(--ky-ink)}", ".kyogijo .ky-pl-hw{fill:none;stroke:var(--ky-pe);stroke-width:.7;stroke-opacity:.55}", ".kyogijo .ky-pl-seat{fill:var(--ky-pk);fill-opacity:.2;stroke:var(--ky-pe);stroke-width:.3;stroke-opacity:.5}", ".kyogijo .ky-pl-rows{fill:none;stroke:var(--ky-pe);stroke-width:.25;stroke-opacity:.35}"],
+};
+/** The palette's rules for one or more sports (`.kyogijo[data-sport=...]`): in light, in dark by the device's setting, and in dark by the page's or the drawing's own. */
+function palette(sports, paint) {
+    const light = { ...LIGHT, ...SAME, ...(paint ? LIGHT_PAINT : {}) };
+    const dark = { ...DARK, ...(paint ? DARK_PAINT : {}) };
+    return [
+        `:where(${sports.map((s) => `.kyogijo[data-sport=${s}]`).join(",")}){${declarations(light)}}`,
+        `@media (prefers-color-scheme:dark){:where(${sports.map((s) => `html:not([data-theme=light]) .kyogijo[data-sport=${s}]:not([data-theme=light])`).join(",")}){${declarations(dark)}}}`,
+        `:where(${sports.flatMap((s) => [`html[data-theme=dark] .kyogijo[data-sport=${s}]`, `.kyogijo[data-theme=dark][data-sport=${s}]`]).join(",")}){${declarations(dark)}}`,
+    ].join("\n");
+}
+/**
+ * The stylesheet of a pool drawing, with only what it uses: the palette for its sport, the rules of the ropes, its sport's own, and, if it has them, the light on the water, the tiles, the labels of a race and a
+ * section.
+ */
+export function poolStyle(use) {
+    const lit = use.look !== "flat";
+    const parts = [palette([use.sport], lit || use.deck === "tiled"), ...RULES.common];
+    if (lit)
+        parts.push(...RULES.light);
+    if (use.look === "tiled")
+        parts.push(...RULES.floor);
+    if (use.deck === "tiled")
+        parts.push(...RULES.deck);
+    if (use.sport === "swimming")
+        parts.push(...RULES.swimming);
+    if (use.race)
+        parts.push(...RULES.race);
+    if (use.section)
+        parts.push(...RULES.section);
+    if (use.hall === true)
+        parts.push(...RULES.hall);
+    if (use.sport === "waterpolo" || use.sport === "diving" || use.sport === "artisticswimming")
+        parts.push(...RULES[use.sport]);
+    return parts.join("\n");
+}
+/** The rules of every pool, for a page that draws with `style: "none"` and supplies the stylesheet itself. */
+export const KYOGIJO_POOL_STYLE = [palette(POOL_SPORTS, true), ...RULES.common, ...RULES.light, ...RULES.floor, ...RULES.deck, ...RULES.swimming, ...RULES.race, ...RULES.section, ...RULES.waterpolo, ...RULES.diving, ...RULES.artisticswimming, ...RULES.hall].join("\n");

package/dist/pool.types.d.ts

@@ -0,0 +1,145 @@
+/** The sports of the pool: the swimming pool, the water polo field, the diving well and the artistic swimming area. */
+export type PoolSport = "swimming" | "waterpolo" | "diving" | "artisticswimming";
+/**
+ * How the water is painted: `flat` (the default) is one clean colour; `water` lays a faint, seeded pattern of light on it, deeper blue at the middle of a long pool; `tiled` shows the tiles of the floor
+ * through the water as well.
+ */
+export type PoolLook = "flat" | "water" | "tiled";
+/** How the deck is painted: one colour, or in tiles. */
+export type DeckLook = "plain" | "tiled";
+/** The swimming pool of a competition, or a warm-up pool: the same lanes and ropes, without the starting blocks, the flags and the false start rope. */
+export type PoolKind = "competition" | "warm-up";
+/** Why a swimmer has no time. */
+export type SwimmerStatus = "dq" | "dns" | "dnf";
+/**
+ * One swimmer in a lane: who is in it, and, once the race is swum, what happened. The caller passes the flag (an `https:` address, an image `data:` address or an SVG document as text, held to the rules of
+ * a team's `logo`); the package bundles no flags. Times are seconds (`26.12`) or text (`"1:46.91"`).
+ */
+export interface Swimmer {
+    /** The lane, as the pool numbers them (1 to 8, or 0 to 9 in a ten-lane pool). */
+    lane: number;
+    name: string;
+    /** A short form for the label: the country's three letters, or a club's. */
+    abbr?: string;
+    /** The flag or crest, drawn small beside the name. */
+    flag?: string;
+    /** The swimmer's colour (a cap, a club), drawn as a stripe on the label. */
+    color?: string;
+    /** The entry time. */
+    seed?: number | string;
+    /** The final time. */
+    time?: number | string;
+    /** The place: 1, 2 and 3 get a gold, a silver and a bronze medal. Worked out from the times when it is missing and every swimmer has one. */
+    place?: number;
+    /** The reaction time off the block, in seconds (`0.62`). */
+    reaction?: number;
+    /** The cumulative time at each split: at 50, 100 and 150 m of a 200 m race, or each 25 m of a short course. The last is the final time. */
+    splits?: readonly (number | string | null | undefined)[];
+    /** `dq`, `dns` or `dnf`, written in place of a time. */
+    status?: SwimmerStatus;
+    /** A record the swim set: `WR`, `OR`, `CR`... written beside the time. */
+    record?: string;
+}
+/** What the labels of a race show. Everything that has data is shown unless it says `false`. */
+export interface RaceShow {
+    names?: boolean;
+    flags?: boolean;
+    results?: boolean;
+    reaction?: boolean;
+    splits?: boolean;
+    medals?: boolean;
+    seeds?: boolean;
+}
+/** The split pace bars drawn in the lanes: each split of a race as a bar whose length is the share of the lane that split is, and whose colour is its pace against the field's. */
+export interface PaceOptions {
+    /** Write the pace in seconds per 100 m on each bar. On by default. */
+    labels?: boolean;
+}
+/** A race: the event, its distance, and the swimmers in their lanes. */
+export interface PoolRace {
+    /** The name of the event: "Women's 200 m butterfly, final". */
+    event?: string;
+    /** The distance in metres. Worked out from the splits (the number of splits times the distance between them) when it is missing, else the length of the course. */
+    distance?: number;
+    /** The metres between two splits: 50 in a long course pool and 25 in a short course one, unless this says another. */
+    splitEvery?: number;
+    swimmers: readonly Swimmer[];
+    show?: RaceShow;
+    /** Draw the splits as pace bars in the lanes. */
+    pace?: boolean | PaceOptions;
+}
+/** The boards of a diving well that can be asked for. */
+export type DivingPlatform = 1 | 3 | 5 | 7.5 | 10;
+/** One pool of a natatorium: which pool it is, and where, in metres from the hall's top left corner. A pool with no place is put by the layout. */
+export interface VenuePool {
+    sport: PoolSport;
+    /** A name for the plan's label. The pool's own by default. */
+    name?: string;
+    /** For a swimming pool: its course and kind (`short` and `warm-up` for a warm-up pool). */
+    course?: "long" | "short";
+    kind?: PoolKind;
+    lanes?: number;
+    x?: number;
+    y?: number;
+}
+/** A natatorium: several pools in one hall, to scale, kept the distance the rules ask of a swimming pool and a diving well. */
+export interface VenueOptions {
+    pools: readonly VenuePool[];
+    /** The metres between two pools. 10 (the preferred distance of the rules) by default. */
+    apart?: number;
+    /** Write each pool's name on the plan. On by default. */
+    labels?: boolean;
+    /** Draw the seating for spectators along the top of the hall. On by default. */
+    seating?: boolean;
+}
+/** A side section of a swimming pool: its depth profile, the blocks, the flags and the false start rope. */
+export interface PoolSection {
+    /** The water's depth in metres. The rules' least for the pool: 2.5 for a 50 m pool, 2.0 for a 25 m one. */
+    depth?: number;
+    /** How much taller than long the section is drawn. 2.5 by default; the section is not to scale otherwise. */
+    exaggerate?: number;
+}
+/**
+ * The look, the size and the data of a pool. Every part is optional. The sport (`swimming`, `waterpolo`, `diving`, `artisticswimming`) says which pool it is; the parts that belong to one pool are
+ * said so in their descriptions.
+ */
+export interface PoolStyle {
+    /** Swimming: `long` (50 m, the default) or `short` (25 m). */
+    course?: "long" | "short";
+    /** Swimming: the lanes, 1 to 10. 8 by default. Ten lanes are numbered 0 to 9. */
+    lanes?: number;
+    /** Swimming: a temporary pool (26 m wide, ten lanes of 2.5 m) in place of a permanent one (25 m, lanes 0 and 9 of 2.4 m). Only for a ten-lane pool. */
+    temporary?: boolean;
+    /** Swimming: `competition` (the default) or `warm-up`, a pool of the same lanes without blocks, flags or false start rope. */
+    kind?: PoolKind;
+    /** How the water is painted: `flat`, `water` or `tiled`. */
+    look?: PoolLook;
+    /** `plain` or `tiled` deck. */
+    deck?: DeckLook;
+    /** The seed of the light on the water (`look: "water"`). The same seed always draws the same light. 1 by default. */
+    seed?: number;
+    /** Swimming: the starting blocks, with their lane numbers. On in a competition pool. */
+    blocks?: boolean;
+    /** Swimming: the touch panels on the end walls. On in a competition pool. */
+    pads?: boolean;
+    /** Swimming: the backstroke turn flags at 5 m from each end. On in a competition pool. */
+    flags?: boolean;
+    /** Swimming: the false start rope at 15 m from the starting end. On in a competition pool. */
+    falseStart?: boolean;
+    /** Swimming: a side section under the plan, with the depth. */
+    section?: boolean | PoolSection;
+    /** Swimming: the lanes of a race, with the names, the flags, the results and the splits. */
+    race?: PoolRace;
+    /** Water polo: the side of the field the official table is on, as the field is drawn wide: `bottom` (the default) or `top`. */
+    table?: "top" | "bottom";
+    /** Diving: the platforms to draw (1, 3, 5, 7.5, 10). 5, 7.5 and 10 by default. */
+    platforms?: readonly DivingPlatform[];
+    /** Diving: draw the springboards (the 1 m and the 3 m). On by default. */
+    springboards?: boolean;
+    /** Diving: how many boards of each height, 2 each by default (a synchronised pair stands side by side). */
+    boards?: number;
+    /** Artistic swimming: the routine area of the Olympic Games and the World Championships (`olympic`, 30 by 20 m) or the least (`minimum`, 25 by 15 m with a 12 by 12 m deep part). */
+    area?: "olympic" | "minimum";
+    /** Several pools in one hall: `natatorium`, or a list of your own. Swimming only; the pool of the options is the competition pool. */
+    venue?: "natatorium" | VenueOptions;
+}

package/dist/pool.types.js

@@ -0,0 +1,3 @@
+// The types of the aquatic sports: the options of a pool, the lanes of a race and what a swimmer did in it. Plain data only (numbers, text and lists), so that a race can be saved as JSON
+// and the same race always draws the same picture.
+export {};

package/dist/pool.words.d.ts

@@ -0,0 +1,13 @@
+import { type PoolPlan } from "./pool.ts";
+import { STATUS_TEXT } from "./pool.race.ts";
+import type { Language, SurfaceOptions } from "./types.ts";
+/** The plan of a pool sport's options. */
+export declare function planOf(o: Pick<SurfaceOptions, "sport" | "pool">): PoolPlan;
+/** Items as a list in a language: "a, b and c". */
+export declare function listOf(items: readonly string[], language: Language): string;
+/** What the pool is, as a fragment for the description, and the sentences that follow it. */
+export declare function poolDescription(o: Pick<SurfaceOptions, "sport" | "pool">, language: Language): {
+    about: string;
+    after: string[];
+};
+export { STATUS_TEXT };

package/dist/pool.words.js

@@ -0,0 +1,101 @@
+// What a pool says of itself in a drawing's description, in a language: what the pool is, how big, with how many lanes or which boards, the lanes of a race with their places, times and splits, and the side section.
+import { artisticPlan, divePlan, poloPlan, swimPlan, venueOf } from "./pool.js";
+import { STATUS_TEXT, formatTime } from "./pool.race.js";
+import { MEDALS } from "./pool.labels.js";
+import { WATER_POLO } from "./pool.figures.js";
+import { KYOGIJO_STRINGS, fill } from "./strings.js";
+const trimmed = (value) => String(Math.round(value * 100) / 100);
+/** The plan of a pool sport's options. */
+export function planOf(o) {
+    switch (o.sport) {
+        case "swimming":
+            return swimPlan(o);
+        case "waterpolo":
+            return poloPlan(o);
+        case "diving":
+            return divePlan(o);
+        default:
+            return artisticPlan(o);
+    }
+}
+const sizeText = (language, length, width) => fill(KYOGIJO_STRINGS[language].pool.size, { length: trimmed(length), width: trimmed(width) });
+/** Items as a list in a language: "a, b and c". */
+export function listOf(items, language) {
+    const w = KYOGIJO_STRINGS[language].pool;
+    return items.length < 2 ? items.join("") : `${items.slice(0, -1).join(w.sep)}${w.last}${items[items.length - 1]}`;
+}
+/** The sentences about the lanes of a race, one for each swimmer that has a lane, in the order down the page. */
+function raceSentences(plan, language) {
+    const race = plan.race;
+    if (race === undefined)
+        return [];
+    const words = KYOGIJO_STRINGS[language];
+    const w = words.pool;
+    const { stop } = words.said;
+    const out = [];
+    if (race.event !== undefined)
+        out.push(`${fill(w.event, { event: race.event })}${/[.。]$/.test(race.event) ? "" : stop}`);
+    for (const row of race.rows) {
+        const parts = [`${fill(w.lane, { lane: row.lane, name: row.name })}${row.abbr === "" ? "" : fill(w.abbr, { abbr: row.abbr })}`];
+        if (race.show.results && row.status !== undefined)
+            parts.push(w.status[row.status]);
+        else if (race.show.results) {
+            if (row.place !== undefined)
+                parts.push(fill(w.place, { n: row.place }));
+            if (race.show.medals && row.place !== undefined && MEDALS[row.place] !== undefined)
+                parts.push(w.medal[["gold", "silver", "bronze"][row.place - 1]]);
+            if (row.timeText !== undefined)
+                parts.push(fill(w.time, { time: row.timeText }));
+            if (race.show.reaction && row.reaction !== undefined)
+                parts.push(fill(w.reaction, { rt: row.reaction.toFixed(2) }));
+            if (race.show.splits && row.splits.some((s) => Number.isFinite(s)))
+                parts.push(fill(w.splits, { list: row.splits.filter((s) => Number.isFinite(s)).map(formatTime).join(w.joiner) }));
+            if (row.record !== undefined)
+                parts.push(fill(w.record, { record: row.record }));
+        }
+        if (race.show.seeds && row.seed !== undefined && row.timeText === undefined && row.status === undefined)
+            parts.push(fill(w.seed, { time: row.seed }));
+        out.push(`${parts.join(w.joiner)}${stop}`);
+    }
+    if (race.pace !== null && race.fastest !== undefined)
+        out.push(w.pace);
+    return out;
+}
+/** What the pool is, as a fragment for the description, and the sentences that follow it. */
+export function poolDescription(o, language) {
+    const words = KYOGIJO_STRINGS[language];
+    const w = words.pool;
+    const venue = o.sport === "swimming" && o.pool?.venue !== undefined ? venueOf(o.pool) : undefined;
+    if (venue !== undefined) {
+        const names = venue.pools.map((pool) => {
+            const key = pool.sport === "swimming" ? (pool.kind === "warm-up" ? "warmUp" : "competition") : pool.sport === "diving" ? "diving" : pool.sport === "waterpolo" ? "waterPolo" : "artistic";
+            return pool.name ?? w.names[key];
+        });
+        return { about: fill(w.venue, { n: venue.pools.length, list: listOf(names, language) }).replace(/[.。]$/, ""), after: [] };
+    }
+    const plan = planOf(o);
+    switch (plan.sport) {
+        case "swimming": {
+            const lanes = plan.lanes.length === 1 ? w.laneOne : fill(w.lanes, { n: plan.lanes.length });
+            const about = fill(plan.kind === "warm-up" ? w.aboutWarmUp : w.aboutSwimming, { size: sizeText(language, plan.length, plan.width), lanes });
+            const after = raceSentences(plan, language);
+            if (plan.section !== undefined)
+                after.push(fill(w.section, { depth: trimmed(plan.depth) }));
+            return { about, after };
+        }
+        case "waterpolo":
+            return { about: fill(w.aboutWaterPolo, { size: sizeText(language, WATER_POLO.length, WATER_POLO.width) }), after: [] };
+        case "diving": {
+            const heights = plan.boards.filter((b) => b.kind === "platform").map((b) => b.height).sort((a, b) => a - b);
+            const hasBoards = plan.boards.some((b) => b.kind === "springboard");
+            const list = listOf(heights.map(String), language);
+            const boards = [hasBoards ? w.boards : "", heights.length > 0 ? fill(w.platforms, { list }) : ""].filter((part) => part !== "").join(w.and);
+            return { about: fill(w.aboutDiving, { size: sizeText(language, plan.length, plan.width), boards: boards === "" ? "" : boards }).replace(/,\s*with\s*$/, "").replace(/で、があります$/, "です"), after: [] };
+        }
+        default: {
+            const deep = plan.deep === undefined ? "" : fill(w.deep, { size: sizeText(language, plan.deep.length, plan.deep.width) });
+            return { about: `${fill(w.aboutArtistic, { size: sizeText(language, plan.length, plan.width) })}${deep}`, after: [] };
+        }
+    }
+}
+export { STATUS_TEXT };

package/dist/ranges.names.js

@@ -17,12 +17,19 @@ export const RANGES = Object.freeze({
     nba: Object.freeze([range("half-court", "left"), range("paint", "left")]),
     soccer: Object.freeze([range("half", "left"), range("final-third", "right"), range("defensive-third", "left"), range("middle-third"), range("penalty-area", "left")]),
     mlb: Object.freeze([range("infield"), range("outfield")]),
-    curling: Object.freeze([range("sheet"), range("half", "left"), range("house", "left")]),
+    curling: Object.freeze([range("sheet"), range("half", "left"), range("house", "left"), range("folded")]),
     tennis: NET,
     volleyball: NET,
     badminton: NET,
     pickleball: NET,
     tabletennis: NET,
+    padel: NET,
+    squash: NET,
+    racquetball: NET,
+    sepaktakraw: NET,
+    teqball: NET,
+    roundnet: NET,
+    netball: NET,
     lacrosse: Object.freeze([range("half", "left"), range("crease", "right")]),
     rugby: Object.freeze([range("half", "left"), range("twenty-two", "right", ["world-rugby"]), range("twenty", "right", ["nrl", "irl"]), range("in-goal", "right")]),
     afl: Object.freeze([range("half", "left"), range("forward-fifty", "right"), range("centre-square")]),
@@ -30,6 +37,41 @@ export const RANGES = Object.freeze({
     cricket: Object.freeze([range("pitch"), range("circle", undefined, ["icc-men", "icc-women"])]),
     fieldhockey: Object.freeze([range("half", "left"), range("circle", "right"), range("twenty-three", "right")]),
     handball: Object.freeze([range("half", "left"), range("goal-area", "right")]),
+    swimming: Object.freeze([range("half", "left"), range("pool-end", "left")]),
+    waterpolo: Object.freeze([range("half", "left"), range("goal-area", "right")]),
+    diving: Object.freeze([range("springboards", "left"), range("platforms", "right")]),
+    artisticswimming: Object.freeze([range("half", "left"), range("centre-stage")]),
+    // The bends are the first (right) and the second (left); the field events are at the end of the stadium where the standard layout puts them (a range with two ends has both, one with one has that end).
+    // The long track, the short track and the figure skating rink share a sport: a range is for the leagues that have it.
+    skating: Object.freeze([
+        range("home-straight", undefined, ["isu-long-track", "isu-short-track"]),
+        range("crossing-straight", undefined, ["isu-long-track", "isu-short-track"]),
+        range("first-bend", "right", ["isu-long-track", "isu-short-track"]),
+        range("second-bend", "left", ["isu-long-track", "isu-short-track"]),
+        range("finish", undefined, ["isu-long-track", "isu-short-track"]),
+        range("start", undefined, ["isu-long-track", "isu-short-track"]),
+        range("infield", undefined, ["isu-long-track", "isu-short-track"]),
+        range("half", "left", ["isu-figure"]),
+        range("judges", undefined, ["isu-figure"]),
+        range("kiss-and-cry", "left", ["isu-figure"]),
+    ]),
+    athletics: Object.freeze([
+        range("bend", "right"),
+        range("home-straight"),
+        range("back-straight"),
+        range("finish"),
+        range("start"),
+        range("infield"),
+        range("high-jump", "right"),
+        range("pole-vault", "left"),
+        range("long-jump"),
+        range("triple-jump"),
+        range("shot-put", "left"),
+        range("discus-throw", "right"),
+        range("hammer-throw", "right"),
+        range("javelin-throw", "left"),
+        range("water-jump", "left"),
+    ]),
 });
 const isNumber = (value) => typeof value === "number" && Number.isFinite(value);
 /**
@@ -52,9 +94,11 @@ export function parseRange(o) {
         const leagueId = league?.id ?? LEAGUES[sport]?.[0]?.id;
         if (info.leagues !== undefined && leagueId !== undefined && !info.leagues.includes(leagueId))
             throw new RangeError(`The ${sport} league "${leagueId}" has no range "${name}": it is for ${info.leagues.join(" and ")}`);
-        if (end !== undefined && end !== "left" && end !== "right")
+        // A curling sheet's ends are also read as a tall sheet's: the top end is the left one and the bottom end the right.
+        const asked = sport === "curling" && end === "top" ? "left" : sport === "curling" && end === "bottom" ? "right" : end;
+        if (asked !== undefined && asked !== "left" && asked !== "right")
             throw new RangeError(`A range's end is "left" or "right", not "${String(end)}"`);
-        return { kind: "name", name: info.id, end: info.end === undefined ? undefined : (end ?? info.end), asked: end };
+        return { kind: "name", name: info.id, end: info.end === undefined ? undefined : (asked ?? info.end), asked: asked };
     }
     const box = given;
     if (typeof given !== "object" || !isNumber(box.x0) || !isNumber(box.x1) || !isNumber(box.y0) || !isNumber(box.y1))

package/dist/replay-entry.d.ts

@@ -1,5 +1,8 @@
 export { activeEvents, describeEvent, drawFrame, eventsBetween, interpolate, possession, replayClock, replayEvents, replayInfo, replayLayers, replaySnapshot, replaySummary, replayTable, replayTimes, trails } from "./replay.ts";
 export type { ReplaySnapshot } from "./replay.ts";
+export { alongPool, distanceAt, progressOf, raceTimeline } from "./pool.replay.ts";
+export type { Progress, RaceReplayOptions } from "./pool.replay.ts";
+export { formatTime, parseTime } from "./pool.race.ts";
 export { REPLAY_SPEEDS, REPLAY_SPEED_RANGE, createReplay } from "./replay.control.ts";
 export type { ReplayController } from "./replay.control.ts";
 export type { ActiveEvent, Possession, ReplayChange, ReplayEvent, ReplayEventKind, ReplayFrame, ReplayLook, ReplayObject, ReplayReason, ReplaySettings, ReplayState, ReplayTeam, ReplayTimeline, ReplayTrail, } from "./replay.types.ts";

package/dist/replay-entry.js

@@ -1,4 +1,6 @@
 // Replay: tracking data over time on a surface. The frame, the clock and the pure functions between them; the controls and the animation
 // are in the mount (`mountKyogijo(...).replay(...)`) and in `<kyogijo-field>`.
 export { activeEvents, describeEvent, drawFrame, eventsBetween, interpolate, possession, replayClock, replayEvents, replayInfo, replayLayers, replaySnapshot, replaySummary, replayTable, replayTimes, trails } from "./replay.js";
+export { alongPool, distanceAt, progressOf, raceTimeline } from "./pool.replay.js";
+export { formatTime, parseTime } from "./pool.race.js";
 export { REPLAY_SPEEDS, REPLAY_SPEED_RANGE, createReplay } from "./replay.control.js";