@johnmorrisdotca/kyogijo-stadiums 0.0.0-stage → 0.4.0

package/dist/leagues.js

@@ -0,0 +1,462 @@
+// The leagues: for each family of surface (basketball, hockey, football, baseball and softball) the variants a rulebook marks
+// differently, each with the figures of its own rulebook in its own unit, its name in English and Japanese, the sources that say so
+// and, where a source dates it, the markings it had in earlier seasons. `league` in the options picks one; `sport` names the family
+// (`nba` for basketball, `nhl` for hockey, `nfl`, `cfl` and `ifaf` for football, `mlb` for baseball and softball).
+// Nothing here draws.
+import { BASEBALL_LEAGUES, diamondInFeet } from "./leagues/baseball.js";
+import { BASKETBALL_LEAGUES, courtInFeet } from "./leagues/basketball.js";
+import { FOOTBALL_LEAGUES } from "./leagues/football.js";
+import { HOCKEY_LEAGUES, rinkInFeet } from "./leagues/hockey.js";
+import { CURLING_LEAGUES, sheetInFeet } from "./leagues/curling.js";
+import { BADMINTON_LEAGUES, PICKLEBALL_LEAGUES, TABLE_TENNIS_LEAGUES, TENNIS_LEAGUES, VOLLEYBALL_LEAGUES, netInFeet } from "./leagues/courts.js";
+import { AFL_LEAGUES, aflInFeet } from "./leagues/aussie.js";
+import { CRICKET_LEAGUES, cricketInFeet } from "./leagues/cricket.js";
+import { FIELD_HOCKEY_LEAGUES, fieldHockeyInFeet } from "./leagues/fieldhockey.js";
+import { GAELIC_LEAGUES, gaelicInFeet } from "./leagues/gaelic.js";
+import { HANDBALL_LEAGUES, handballInFeet } from "./leagues/handball.js";
+import { LACROSSE_LEAGUES, lacrosseInFeet } from "./leagues/lacrosse.js";
+import { RUGBY_LEAGUES, rugbyInFeet } from "./leagues/rugby.js";
+import { LEAGUE_SOURCES } from "./leagues/sources.js";
+import { inFeet } from "./leagues/types.js";
+import { convertLength } from "./units.js";
+export { LEAGUE_SOURCES };
+export { AFL_GROUNDS } from "./leagues/aussie.js";
+/** The family of surface each sport draws; soccer's variants are its pitches (`pitch`), not leagues. */
+export const FAMILY_OF = Object.freeze({ nfl: "football", cfl: "football", ifaf: "football", nhl: "hockey", nba: "basketball", mlb: "baseball", soccer: undefined, curling: "curling", tennis: "tennis", volleyball: "volleyball", badminton: "badminton", pickleball: "pickleball", tabletennis: "tabletennis", lacrosse: "lacrosse", rugby: "rugby", afl: "afl", gaelic: "gaelic", cricket: "cricket", fieldhockey: "fieldhockey", handball: "handball" });
+/**
+ * The leagues each sport can draw, in the order a menu lists them, the sport's own first (the three football sports share their
+ * list, the football leagues). Soccer has none.
+ */
+export const LEAGUES = Object.freeze({
+    nba: BASKETBALL_LEAGUES,
+    nhl: HOCKEY_LEAGUES,
+    nfl: FOOTBALL_LEAGUES,
+    cfl: FOOTBALL_LEAGUES,
+    ifaf: FOOTBALL_LEAGUES,
+    mlb: BASEBALL_LEAGUES,
+    soccer: [],
+    curling: CURLING_LEAGUES,
+    tennis: TENNIS_LEAGUES,
+    volleyball: VOLLEYBALL_LEAGUES,
+    badminton: BADMINTON_LEAGUES,
+    pickleball: PICKLEBALL_LEAGUES,
+    tabletennis: TABLE_TENNIS_LEAGUES,
+    lacrosse: LACROSSE_LEAGUES,
+    rugby: RUGBY_LEAGUES,
+    afl: AFL_LEAGUES,
+    gaelic: GAELIC_LEAGUES,
+    cricket: CRICKET_LEAGUES,
+    fieldhockey: FIELD_HOCKEY_LEAGUES,
+    handball: HANDBALL_LEAGUES,
+});
+/** Every league of every family, once each. */
+export const VARIANTS = Object.freeze([...BASKETBALL_LEAGUES, ...HOCKEY_LEAGUES, ...FOOTBALL_LEAGUES, ...BASEBALL_LEAGUES, ...CURLING_LEAGUES, ...TENNIS_LEAGUES, ...VOLLEYBALL_LEAGUES, ...BADMINTON_LEAGUES, ...PICKLEBALL_LEAGUES, ...TABLE_TENNIS_LEAGUES, ...LACROSSE_LEAGUES, ...RUGBY_LEAGUES, ...AFL_LEAGUES, ...GAELIC_LEAGUES, ...CRICKET_LEAGUES, ...FIELD_HOCKEY_LEAGUES, ...HANDBALL_LEAGUES]);
+/** The ids of a sport's leagues. */
+export const leagueIds = (sport) => LEAGUES[sport].map((league) => league.id);
+/** A league by its sport and id, or `undefined`. */
+export function leagueById(sport, id) {
+    return LEAGUES[sport].find((league) => league.id === id);
+}
+/** The unit a league's figures are kept in. */
+const figuresUnit = (league) => league.figuresUnit ?? league.unit;
+/**
+ * Which league the options ask for: the league, and the sport it is drawn as. No `league` is the sport's own. A league the sport's
+ * own (`nba` for `nba`) is the sport as it is drawn without one; one of the football leagues that is a sport of its own (`cfl`) is that
+ * sport. A league of another family, or one that does not exist, is an error that says what to use.
+ * @example
+ * ```ts
+ * import { chooseLeague } from "@johnmorrisdotca/kyogijo-stadiums/leagues";
+ * console.log(chooseLeague({ sport: "nba", league: "fiba" }).league?.name.en, chooseLeague({ sport: "nfl", league: "cfl" }).sport);
+ * // FIBA basketball court cfl
+ * ```
+ */
+export function chooseLeague(o) {
+    if (o.league === undefined || o.league === "")
+        return { sport: o.sport, league: undefined };
+    const id = String(o.league);
+    const family = FAMILY_OF[o.sport];
+    if (family === undefined)
+        throw new Error(`"${String(o.sport)}" has no leagues: a soccer pitch is chosen with pitch`);
+    const found = leagueById(o.sport, id);
+    if (found === undefined) {
+        const elsewhere = Object.keys(FAMILY_OF).find((sport) => FAMILY_OF[sport] !== family && FAMILY_OF[sport] !== undefined && leagueById(sport, id) !== undefined);
+        throw new Error(elsewhere === undefined ? `Unknown league "${id}" for "${o.sport}": use one of ${leagueIds(o.sport).join(", ")}` : `"${id}" is a ${FAMILY_OF[elsewhere]} league: use sport "${elsewhere}" for it`);
+    }
+    if (found.builtIn === true)
+        return { sport: found.family === "football" ? found.id : o.sport, league: undefined };
+    return { sport: o.sport, league: found };
+}
+const historyOf = (league) => Object.entries(league.history ?? {});
+/**
+ * Every change a source dates in a league's markings, in season order, each with a sentence in English and in Japanese and its
+ * sources. A league with no cited history has none (a drawing with a `year` is then the league's rulebook as it is now).
+ * @example
+ * ```ts
+ * import { leagueChanges } from "@johnmorrisdotca/kyogijo-stadiums/leagues";
+ * console.log(leagueChanges("nba", "ncaa-men").map((change) => change.id));
+ * ```
+ */
+export function leagueChanges(sport, id) {
+    const league = leagueById(sport, id);
+    if (league === undefined)
+        throw new Error(`Unknown league "${id}" for "${String(sport)}"`);
+    return historyOf(league)
+        .flatMap(([feature, spans]) => spans.map((span) => ({ id: `${league.id}.${feature}.${span.from === null ? "start" : span.from}`, league: league.id, feature, from: span.from, value: span.value, what: span.what, ja: span.ja, sources: span.sources })))
+        .sort((a, b) => (a.from ?? -Infinity) - (b.from ?? -Infinity) || a.id.localeCompare(b.id));
+}
+/** True when a league has markings a source dates, so that `year` changes its drawing. */
+export const hasHistory = (league) => league !== undefined && historyOf(league).length > 0;
+/** The markings that hold in a season: the last span that began by then, else the first (a gap). */
+function spanIn(spans, year) {
+    let found;
+    for (const span of spans)
+        if (span.from === null || span.from <= year)
+            found = span;
+    return found === undefined ? { span: spans[0], gap: true } : { span: found, gap: false };
+}
+/**
+ * A league's figures as they were in a season. Without a year, or for a league with no dated history, they are the rulebook's as
+ * it is now.
+ * @example
+ * ```ts
+ * import { leagueAt } from "@johnmorrisdotca/kyogijo-stadiums/leagues";
+ * console.log(leagueAt("nba", "ncaa-men", 2010).differences.map((change) => change.id));
+ * // [ 'ncaa-men.restricted.start' ]
+ * ```
+ */
+export function leagueAt(sport, id, year) {
+    const league = leagueById(sport, id);
+    if (league === undefined)
+        throw new Error(`Unknown league "${id}" for "${String(sport)}"`);
+    return leagueAtOf(league, year);
+}
+/** `leagueAt` for a league already in hand. */
+export function leagueAtOf(league, year) {
+    const asked = typeof year === "number" && Number.isFinite(year) ? Math.floor(year) : undefined;
+    const figures = { ...league.dimensions };
+    const differences = [];
+    const gaps = [];
+    if (asked !== undefined) {
+        for (const [feature, spans] of historyOf(league)) {
+            const { span, gap } = spanIn(spans, asked);
+            figures[feature] = span.value;
+            if (gap)
+                gaps.push(feature);
+            else if (JSON.stringify(span.value) !== JSON.stringify(league.dimensions[feature])) {
+                differences.push({ id: `${league.id}.${feature}.${span.from === null ? "start" : span.from}`, league: league.id, feature, from: span.from, value: span.value, what: span.what, ja: span.ja, sources: span.sources });
+            }
+        }
+    }
+    return { league, year: asked, figures: figures, differences, gaps };
+}
+/** The name of a season as the family writes it: `1979–80` for basketball and hockey, which play across the new year, else `1979`. */
+export function leagueSeason(family, year) {
+    const y = Math.floor(year);
+    return family === "basketball" || family === "hockey" ? `${y}–${String((y + 1) % 100).padStart(2, "0")}` : String(y);
+}
+/** A basketball court of a league in a season, in feet. */
+export const courtOf = (league, year) => courtInFeet(leagueAtOf(league, year).figures, figuresUnit(league));
+/** An ice rink of a league in a season, in feet. */
+export const rinkOf = (league, year) => rinkInFeet(leagueAtOf(league, year).figures, figuresUnit(league));
+/** A curling sheet of a league, in feet. A sheet has no history; a year is ignored. */
+export const sheetOf = (league = CURLING_LEAGUES[0]) => sheetInFeet(league.dimensions, league.figuresUnit ?? league.unit);
+/** A net sport's court of a league (tennis, volleyball and beach volleyball, badminton, pickleball, table tennis), in feet. These courts have no history; a year is ignored. */
+export const netOf = (league) => netInFeet(league.dimensions, figuresUnit(league));
+/** A lacrosse surface of a league, in feet (the box floor, or a field). These have no history; a year is ignored. */
+export const lacrosseOf = (league) => lacrosseInFeet(league.dimensions, figuresUnit(league));
+/** A rugby field of a league, in feet. */
+export const rugbyOf = (league) => rugbyInFeet(league.dimensions, figuresUnit(league));
+/** The Australian football ground, in feet. */
+export const aflOf = (league) => aflInFeet(league.dimensions, figuresUnit(league));
+/** A Gaelic games field of a league (football or hurling), in feet. */
+export const gaelicOf = (league) => gaelicInFeet(league.dimensions, figuresUnit(league));
+/** A cricket ground of a league, in feet. */
+export const cricketOf = (league) => cricketInFeet(league.dimensions, figuresUnit(league));
+/** A field hockey pitch, in feet. */
+export const fieldHockeyOf = (league) => fieldHockeyInFeet(league.dimensions, figuresUnit(league));
+/** A handball court, in feet. */
+export const handballOf = (league) => handballInFeet(league.dimensions, figuresUnit(league));
+/** A football field of a league in a season: the spec, in feet. */
+export const fieldOf = (league, year) => inFeet(leagueAtOf(league, year).figures, figuresUnit(league));
+/** A diamond of a league in a season, in feet. */
+export const diamondOf = (league, year) => diamondInFeet(leagueAtOf(league, year).figures, figuresUnit(league));
+/**
+ * The length and the width of a league's surface in a unit (the league's own when none is given): a football field with its end
+ * zones, end line to end line. A diamond has no fixed size, its fence is its size.
+ * @example
+ * ```ts
+ * import { leagueSize } from "@johnmorrisdotca/kyogijo-stadiums/leagues";
+ * console.log(leagueSize("nba", "nba"));
+ * // { length: 94, width: 50, unit: 'ft' }
+ * ```
+ */
+export function leagueSize(sport, id, unit) {
+    const league = leagueById(sport, id);
+    if (league === undefined)
+        throw new Error(`Unknown league "${id}" for "${String(sport)}"`);
+    const to = unit ?? league.unit;
+    let feet;
+    switch (league.family) {
+        case "basketball":
+            feet = courtOf(league);
+            break;
+        case "hockey":
+            feet = rinkOf(league);
+            break;
+        case "curling":
+            feet = sheetOf(league);
+            break;
+        case "tennis": {
+            const t = netOf(league);
+            feet = { length: t.length, width: t.widthDoubles };
+            break;
+        }
+        case "volleyball":
+        case "badminton":
+        case "pickleball":
+        case "tabletennis":
+            feet = netOf(league);
+            break;
+        case "football": {
+            const field = fieldOf(league);
+            feet = { length: field.length + 2 * field.endZone, width: field.width };
+            break;
+        }
+        case "lacrosse": {
+            const f = lacrosseOf(league);
+            feet = { length: f.length.drawn, width: f.width.drawn };
+            break;
+        }
+        case "rugby": {
+            const f = rugbyOf(league);
+            feet = { length: f.length.drawn + 2 * f.inGoal.drawn, width: f.width.drawn };
+            break;
+        }
+        case "afl":
+        case "gaelic":
+        case "fieldhockey":
+        case "handball": {
+            const f = league.family === "afl" ? aflOf(league) : league.family === "gaelic" ? gaelicOf(league) : league.family === "fieldhockey" ? fieldHockeyOf(league) : handballOf(league);
+            feet = { length: f.length.drawn, width: f.width.drawn };
+            break;
+        }
+        case "cricket": {
+            const f = cricketOf(league);
+            feet = { length: 2 * f.boundary.drawn, width: 2 * f.boundary.drawn };
+            break;
+        }
+        default:
+            throw new Error(`No fixed size for the ${league.family} league "${id}": a diamond's size is its fence`);
+    }
+    return { length: convertLength(feet.length, "ft", to), width: convertLength(feet.width, "ft", to), unit: to };
+}
+/** A length in feet written in a unit: metres to two places, feet and inches (`22 ft 1.75 in`), yards to two places. */
+function written(feet, unit) {
+    const trim = (n, places) => String(Math.round(n * 10 ** places) / 10 ** places);
+    if (unit === "m")
+        return `${trim(convertLength(feet, "ft", "m"), 3)} m`;
+    if (unit === "yd")
+        return `${trim(feet / 3, 2)} yd`;
+    const whole = Math.floor(feet + 1e-9);
+    const inches = Math.round((feet - whole) * 12 * 100) / 100;
+    return inches === 0 ? `${whole} ft` : whole === 0 ? `${trim(inches, 2)} in` : `${whole} ft ${trim(inches, 2)} in`;
+}
+/**
+ * The key figures of a league in words, each in the unit its rulebook uses: for a table of the leagues (docs/variants.md) and for a
+ * test that holds the drawing to the rulebook.
+ * @example
+ * ```ts
+ * import { LEAGUES, leagueFigures } from "@johnmorrisdotca/kyogijo-stadiums/leagues";
+ * const fiba = LEAGUES.nba.find((league) => league.id === "fiba")!;
+ * console.log(leagueFigures(fiba).slice(0, 2).map(([name, value]) => `${name}: ${value}`).join("; "));
+ * // court: 28 m by 15 m; lane: 4.9 m wide
+ * ```
+ */
+export function leagueFigures(league) {
+    const u = league.unit;
+    const w = (feet) => written(feet, u);
+    switch (league.family) {
+        case "basketball": {
+            const c = courtOf(league);
+            return [
+                ["court", `${w(c.length)} by ${w(c.width)}`],
+                ["lane", `${w(c.laneWidth)} wide`],
+                ["free-throw line", `${w(c.freeThrowLine)} from the baseline`],
+                ["three-point line", c.threePoint === null ? "none" : `${w(c.threePoint.radius)} arc, straights ${w(c.threePoint.sideInset)} from the sidelines`],
+                ["restricted area", c.restricted === null ? "none" : `${w(c.restricted)} arc`],
+            ];
+        }
+        case "hockey": {
+            const r = rinkOf(league);
+            return [
+                ["rink", `${w(r.length)} by ${w(r.width)}`],
+                ["corner radius", w(r.cornerRadius)],
+                ["goal line", `${w(r.goalLine)} from the end boards`],
+                ["blue line", `${w(r.blueLine)} from the end boards`],
+                ["face-off circle", `${w(r.circleRadius)} radius`],
+                ["trapezoid", r.trapezoid === null ? "none" : `${w(r.trapezoid.atGoalLine)} at the goal line, ${w(r.trapezoid.atBoards)} at the boards`],
+            ];
+        }
+        case "curling": {
+            const s = sheetOf(league);
+            const [twelve, eight, four, button] = s.rings;
+            return [
+                ["sheet", `${w(s.length)} by ${w(s.width)}`],
+                ["least sheet", `${w(s.lengthMin)} by ${w(s.widthMin)}`],
+                ["tee to tee", `${w(2 * s.teeFromMiddle)}`],
+                ["back line", `${w(s.backLine)} from the tee`],
+                ["hog line", `${w(s.hogLine)} from the tee`],
+                ["house", `circles of ${w(twelve)}, ${w(eight)} and ${w(four)} radius, a button of ${w(button)}`],
+                ["courtesy line", s.courtesy === null ? "none" : `${w(s.courtesy.outsideHog)} outside each hog line`],
+            ];
+        }
+        case "tennis": {
+            const t = netOf(league);
+            return [
+                ["court", `${w(t.length)} by ${w(t.widthDoubles)} (singles ${w(t.widthSingles)} wide)`],
+                ["service line", `${w(t.serviceLine)} from the net`],
+                ["net", `${w(t.net.heightPosts)} at the posts, ${w(t.net.heightCentre)} at the centre`],
+                ["net posts", `${w(t.net.postsOutside)} outside the doubles court`],
+                ["free zone", t.free.official === null ? "none" : `${w(t.free.official.end)} behind the baselines, ${w(t.free.official.side)} beside the sidelines`],
+            ];
+        }
+        case "volleyball": {
+            const v = netOf(league);
+            return [
+                ["court", `${w(v.length)} by ${w(v.width)}`],
+                ["attack line", v.attackLine === null ? "none" : `${w(v.attackLine)} from the centre line`],
+                ["net", `${w(v.net.length)} long, ${w(v.net.heightMen)} high (women's ${w(v.net.heightWomen)})`],
+                ["posts", `${w(v.net.postsOutside)} outside the side lines`],
+                ["free zone", v.free.official === null ? "none" : `${w(v.free.official.end)} behind the end lines, ${w(v.free.official.side)} beside the side lines`],
+            ];
+        }
+        case "badminton": {
+            const b = netOf(league);
+            return [
+                ["court", `${w(b.length)} by ${w(b.width)} (singles ${w(b.width - 2 * b.singlesInset)} wide)`],
+                ["short service line", `${w(b.shortServiceLine)} from the net`],
+                ["doubles long service line", `${w(b.doublesLongServiceInset)} inside the back boundary`],
+                ["net", `${w(b.net.heightCentre)} at the centre, ${w(b.net.heightSides)} over the side lines`],
+            ];
+        }
+        case "pickleball": {
+            const p = netOf(league);
+            return [
+                ["court", `${w(p.length)} by ${w(p.width)}`],
+                ["non-volley zone", `${w(p.nonVolley)} from the net`],
+                ["net", `${w(p.net.heightSides)} at the sidelines, ${w(p.net.heightCentre)} at the centre`],
+                ["playing surface", p.free.least === null ? "none" : `at least ${w(p.width + 2 * p.free.least.side)} by ${w(p.length + 2 * p.free.least.end)}`],
+            ];
+        }
+        case "tabletennis": {
+            const t = netOf(league);
+            return [
+                ["table", `${w(t.length)} by ${w(t.width)}, ${w(t.height)} high`],
+                ["net", `${w(t.net.height)} above the playing surface`],
+                ["lines", `${w(t.edgeLine)} at the edges, a ${w(t.centreLine)} centre line`],
+            ];
+        }
+        case "football": {
+            const f = fieldOf(league);
+            return [
+                ["goal lines", `${written(f.length, "yd")} apart`],
+                ["end zones", written(f.endZone, "yd")],
+                ["width", written(f.width, "yd")],
+                ["hash marks", `${written(f.hash, "ft")} from each sideline`],
+                ["goal posts", `${written(f.postWidth ?? 18.5, "ft")} apart, on the ${f.posts === "end-line" ? "end line" : "goal line"}`],
+            ];
+        }
+        case "rugby": {
+            const f = rugbyOf(league);
+            const r = (x) => (x.min === x.max ? w(x.max) : `${w(x.min)} to ${w(x.max)}`);
+            return [
+                ["field of play", `${r(f.length)} by ${r(f.width)}`],
+                ["in-goal", `${r(f.inGoal)} deep`],
+                ["goal posts", `${w(f.postsApart)} apart, the crossbar ${w(f.crossbar)} up`],
+                f.code === "union" ? ["22-metre line", `${w(f.twentyTwo)} from the try line`] : ["lines across", `every ${w(f.step)} from each goal line`],
+            ];
+        }
+        case "lacrosse": {
+            const f = lacrosseOf(league);
+            const r = (x) => (x.min === x.max ? w(x.max) : `${w(x.min)} to ${w(x.max)}`);
+            const out = [
+                [f.kind === "box" ? "floor" : "field", `${r(f.length)} by ${r(f.width)}`],
+                ["goal", `${w(f.goalWidth)} wide and ${w(f.goalHeight)} high, its line ${w(f.goalLine)} from the end ${f.kind === "box" ? "boards" : "line"}`],
+            ];
+            if (f.crease !== null)
+                out.push(["crease", `a circle of ${w(f.crease)} radius`]);
+            if (f.goalCircle !== null)
+                out.push(["goal circle", `${w(f.goalCircle)} radius`]);
+            if (f.restraining !== null)
+                out.push(["restraining line", `${w(f.restraining)} from the goal line`]);
+            if (f.restrainingFromCentre !== null)
+                out.push(["restraining line", `${w(f.restrainingFromCentre)} from the centre line`]);
+            if (f.twoPoint !== null)
+                out.push(["two-point arc", `${w(f.twoPoint.gle)} from the goal at the goal line extended, then an arc of ${w(f.twoPoint.radius)}`]);
+            return out;
+        }
+        case "afl": {
+            const f = aflOf(league);
+            const r = (x) => `${w(x.min)} to ${w(x.max)}`;
+            return [
+                ["ground", `an oval ${r(f.length)} long and ${r(f.width)} wide`],
+                ["goal posts", `${w(f.goalPosts)} apart, behind posts ${w(f.behindPosts)} either side`],
+                ["goal square", `${w(f.goalSquareDepth)} deep`],
+                ["centre square", `${w(f.centreSquare)} by ${w(f.centreSquare)}`],
+                ["fifty metre arc", `${w(f.fiftyArc)} from the middle of the goal line`],
+            ];
+        }
+        case "gaelic": {
+            const f = gaelicOf(league);
+            const r = (x) => `${w(x.min)} to ${w(x.max)}`;
+            return [
+                ["field", `${r(f.length)} by ${r(f.width)}`],
+                ["lines across", f.lines.map((line) => w(line)).join(", ")],
+                ["goalposts", `${w(f.postsApart)} apart, the crossbar ${w(f.crossbar)} up`],
+                ["rectangles", `${w(f.small.depth)} deep and ${w(f.large.depth)} deep`],
+            ];
+        }
+        case "cricket": {
+            const f = cricketOf(league);
+            // The Laws print yards for the pitch's length and the boundary and feet and inches for the rest.
+            const ft = (feet) => written(feet, "ft");
+            return [
+                ["pitch", `${w(f.pitchLength)} by ${ft(f.pitchWidth)}`],
+                ["bowling crease", `${ft(f.bowlingCrease)} long`],
+                ["popping crease", `${ft(f.poppingCrease)} in front of the bowling crease, marked ${ft(f.poppingEach)} either side of the middle stumps at least`],
+                ["return creases", `${ft(f.returnOutside)} either side of the middle stumps, marked ${ft(f.returnBehind)} behind the popping crease`],
+                ["wickets", `${ft(f.wicket)} wide`],
+                ["boundary", Number.isFinite(f.boundary.max) ? `${w(f.boundary.min)} to ${w(f.boundary.max)} from the centre of the pitch` : "no size given"],
+                ["circle", f.circle === null ? "none" : `${w(f.circle)} radius about each middle stump`],
+            ];
+        }
+        case "fieldhockey": {
+            const f = fieldHockeyOf(league);
+            return [
+                ["pitch", `${w(f.length.max)} by ${w(f.width.max)}`],
+                ["23-metre lines", `${w(f.twentyThree)} from each back-line`],
+                ["circle", `${w(f.circleRadius)} from the back-line`],
+                ["goal", `${w(f.goalWidth)} wide and ${w(f.goalHeight)} high`],
+            ];
+        }
+        case "handball": {
+            const f = handballOf(league);
+            return [
+                ["court", `${w(f.length.max)} by ${w(f.width.max)}`],
+                ["goal area line", `${w(f.areaDistance)} from the goal line`],
+                ["free-throw line", `${w(f.areaDistance + f.freeThrowOutside)} from the goal line`],
+                ["goal", `${w(f.goalWidth)} wide and ${w(f.goalHeight)} high`],
+            ];
+        }
+        default: {
+            const d = diamondOf(league);
+            const f = d.fence;
+            const fence = [f.left, f.center].filter((n) => n !== undefined);
+            return [
+                ["bases", `${written(d.base, "ft")} apart`],
+                ["pitching distance", written(d.pitcher, "ft")],
+                ["fence", f.left === undefined ? "none given" : f.center === undefined || f.center === f.left ? `${written(f.left, "ft")}` : `${written(fence[0], "ft")} at the lines, ${written(fence[1], "ft")} in the middle`],
+            ];
+        }
+    }
+}

package/dist/look.d.ts

@@ -0,0 +1,50 @@
+import type { LookName, Sport } from "./types.ts";
+/** The parts of a palette, each a custom property of the stylesheet. */
+export type PaletteKey = "ink" | "line" | "apron" | "surface" | "alt" | "zone" | "boards" | "red" | "blue" | "dirt" | "foul" | "infield" | "crease" | "key" | "court" | "post" | "pylon" | "rgo" | "rgm" | "rgi" | "rgb" | "hog" | "hack" | "fgz" | "pebble" | "free" | "net" | "area";
+/** Colours by part. */
+export type Palette = Partial<Record<PaletteKey, string>>;
+/** The surfaces that are painted alike: football's three fields are one. */
+export type Group = "football" | "nhl" | "nba" | "mlb" | "soccer" | "curling" | "net";
+/** One mode of a look: a palette for every sport, and what a group of sports changes in it. */
+export interface Mode {
+    base: Palette;
+    groups?: Partial<Record<Group, Palette>>;
+}
+/** A named look. */
+export interface Look {
+    /** What it is for, in a sentence. */
+    about: string;
+    light: Mode;
+    dark: Mode;
+}
+/** The group a sport is painted with, or `undefined` for a surface with no palette of its own (it takes the look's base). */
+export declare const groupOf: (sport: Sport | string) => Group | undefined;
+/**
+ * The named looks. Each is a light and a dark palette for every sport, as custom properties on `.kyogijo[data-palette="<name>"]`; pass one as `look`.
+ * @example
+ * ```ts
+ * import { LOOKS, drawKyogijo } from "@johnmorrisdotca/kyogijo-stadiums";
+ * const svg = drawKyogijo({ sport: "nhl", look: "chalkboard" });
+ * console.log(Object.keys(LOOKS).length, svg.includes('data-palette="chalkboard"'));
+ * // 7 true
+ * ```
+ */
+export declare const LOOKS: Readonly<Record<LookName, Look>>;
+/** The names of the looks, in the order a menu lists them. */
+export declare const LOOK_NAMES: readonly LookName[];
+/** True when a value names a look. */
+export declare const isLook: (value: unknown) => value is LookName;
+/** A look's palette for a sport in one mode: the look's base with what the sport's group changes. */
+export declare function lookPalette(look: LookName, mode: "light" | "dark", sport: Sport | string): Palette;
+/**
+ * The pairs of a palette that must read: what is painted on what, as `[ink, ground, least contrast]` (WCAG 2.2's 3:1 for a line, 4.5:1 for text). The words
+ * of the drawing are on the apron; a line is on the surface and, where its sport paints them under it, on the second tone of the mowing or planks, the key,
+ * the dirt, the infield and the foul ground.
+ */
+export declare const LOOK_PAIRS: Readonly<Record<Group | "all", readonly (readonly [PaletteKey, PaletteKey, number])[]>>;
+/** The contrast ratio of two colours (WCAG 2.2): 1 to 21, or `undefined` when a colour cannot be read without a browser. */
+export declare function contrastOf(a: string | undefined, b: string | undefined): number | undefined;
+/** The stylesheet of one look, light and dark, at no weight. A drawing with a `look` carries its look's. */
+export declare function lookStyle(name: LookName): string;
+/** The stylesheet of every look, for a page that draws with `style: "none"`. */
+export declare const KYOGIJO_LOOK_STYLE: string;