@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.5.0

package/dist/surfaces/pool.js

@@ -0,0 +1,198 @@
+import { el, num } from "../format.js";
+import { feet } from "../pool.js";
+import { box, deckMarkup, leastWidth, paintDefs, poolIds, ropeMarkup, waterMarkup } from "../pool.kit.js";
+import { raceArt } from "../pool.labels.js";
+import { sectionOf } from "../pool.section.js";
+import { SWIMMING } from "../pool.figures.js";
+import { atEnds, edges, ft, quarterTurn, textOn } from "./surface.js";
+/** The gutter round the water, in metres: the width of the coping the pool is drawn with. */
+export const GUTTER = 0.4;
+/**
+ * The body of a swimming pool: every figure is the rules' (`SWIMMING`, pool.figures.ts). The lane markings on the floor are 46 m (21 m in a 25 m pool) long and end 2 m from the walls in a cross line 1 m long (CR 16.2.15); a
+ * cross line 0.5 m long at 15 m from each end; the touch panels 2.4 m wide at the walls with the target lines; the ropes in the rules' colours with red floats within 5 m of the walls and a mark at 15 m and 25 m;
+ * the starting blocks with their lane numbers; the backstroke flags 5 m from each end, and the false start rope 15 m from the starting end.
+ */
+export function swimBody(o, plan, ids) {
+    const L = plan.length;
+    const W = plan.width;
+    const full = o.detail === "full";
+    // Small fixtures are drawn a little larger than they stand, as lines are, unless the true sizes are asked for.
+    const s = o.exact ? 1 : 1.5;
+    let base = box(o, "gutter", "ky-boards", -GUTTER, -GUTTER, L + GUTTER, W + GUTTER);
+    base += waterMarkup(o, ids, plan.look, 0, 0, L, W);
+    let lines = "";
+    const lw = leastWidth(o, SWIMMING.laneLine.width, 0.32);
+    const marks = [];
+    // Under pace bars the lanes are the whole race laid flat, not one length of the pool: the furniture that belongs to a length (floor lines and crosses, the marks at 15 m and 25 m, the red ends of the ropes,
+    // flags, the false start rope, blocks and panels) is left off and the ropes are plain, so that the picture reads as a chart.
+    const neutral = plan.race?.pace !== null && plan.race?.pace !== undefined;
+    // The lane markings and their cross lines on the floor: a line along the middle of each lane, 2 m short of each wall, ending in a cross line 1 m long.
+    const gap = SWIMMING.laneLine.endGap;
+    const half = SWIMMING.laneLine.cross / 2;
+    let d = "";
+    let crosses = "";
+    for (const lane of plan.lanes) {
+        d += `M${num(feet(gap))} ${num(feet(lane.y))}H${num(feet(L - gap))}`;
+        d += `M${num(feet(gap))} ${num(feet(lane.y - half))}V${num(feet(lane.y + half))}M${num(feet(L - gap))} ${num(feet(lane.y - half))}V${num(feet(lane.y + half))}`;
+        if (full)
+            for (const x of [SWIMMING.markAt15, L - SWIMMING.markAt15])
+                crosses += `M${num(feet(x))} ${num(feet(lane.y - SWIMMING.target.crossAt15 / 2))}V${num(feet(lane.y + SWIMMING.target.crossAt15 / 2))}`;
+    }
+    if (!neutral)
+        lines += el("path", { class: ft(o, "lane-lines", "ky-line"), d: d + crosses, "stroke-width": lw, fill: "none" });
+    // The touch panels on the end walls, 2.4 m wide in each lane, with the target line down the middle and its cross line.
+    if (plan.pads && !neutral) {
+        const depth = o.exact ? 0.05 : 0.3;
+        const pad = SWIMMING.pad.width;
+        let pads = "";
+        let targets = "";
+        for (const lane of plan.lanes) {
+            for (const end of [0, 1]) {
+                const x0 = end === 0 ? 0 : L - depth;
+                pads += `M${num(feet(x0))} ${num(feet(lane.y - pad / 2))}h${num(feet(depth))}v${num(feet(pad))}h${num(feet(-depth))}Z`;
+                const wall = end === 0 ? 0 : L;
+                const inward = end === 0 ? 1 : -1;
+                targets += `M${num(feet(wall))} ${num(feet(lane.y))}h${num(feet(inward * depth))}`;
+                if (full)
+                    targets += `M${num(feet(wall + inward * depth * 0.5))} ${num(feet(lane.y - SWIMMING.target.cross / 2))}v${num(feet(SWIMMING.target.cross))}`;
+            }
+        }
+        lines += el("path", { class: ft(o, "touch-pads", "ky-pl-pad"), d: pads });
+        lines += el("path", { class: ft(o, "lane-lines", "ky-line"), d: targets, "stroke-width": lw * 0.85, fill: "none" });
+    }
+    // The ropes: floats in the lane's colour, red within 5 m of each wall, and a distinct run at 15 m and 25 m from the walls.
+    const runs = [];
+    const red = SWIMMING.redEnds;
+    const run = SWIMMING.markRun / 2;
+    for (const rope of plan.ropes) {
+        if (neutral) {
+            runs.push(["white", 0, L, rope.y]);
+            continue;
+        }
+        runs.push([rope.colour, red, L - red, rope.y]);
+        runs.push(["red", 0, red, rope.y], ["red", L - red, L, rope.y]);
+        const at = [SWIMMING.markAt15, L - SWIMMING.markAt15, ...(plan.course === "long" ? [SWIMMING.markAt25] : [])];
+        for (const x of at)
+            runs.push(["white", Math.max(0, x - run), Math.min(L, x + run), rope.y]);
+    }
+    lines += ropeMarkup(o, runs, SWIMMING.floatDiameter, 0.45);
+    // The marks on the deck at 15 m (and 25 m) from the walls, and the standards of the flags: on both sides of the pool (CR 16.1.10).
+    if (full && !neutral) {
+        let ticks = "";
+        for (const x of [SWIMMING.markAt15, L - SWIMMING.markAt15, ...(plan.course === "long" ? [SWIMMING.markAt25] : [])]) {
+            for (const [y0, y1] of [[-GUTTER, 0], [W, W + GUTTER]])
+                ticks += `M${num(feet(x))} ${num(feet(y0))}V${num(feet(y1))}`;
+        }
+        lines += el("path", { class: ft(o, "lane-lines", "ky-line"), d: ticks, "stroke-width": feet(0.22), fill: "none" });
+    }
+    // The false start rope, 15 m from the starting end, on its standards.
+    if (plan.falseStart && !neutral) {
+        const x = SWIMMING.falseStart.at;
+        lines += el("path", { class: ft(o, "false-start-rope", "ky-pl-fs"), d: `M${num(feet(x))} ${num(feet(-0.7))}V${num(feet(W + 0.7))}`, "stroke-width": feet(0.1) * s, fill: "none", "stroke-dasharray": `${num(feet(0.5))} ${num(feet(0.3))}` });
+        if (full)
+            for (const y of [-0.7, W + 0.7])
+                lines += el("circle", { class: "ky-pl-st", cx: feet(x), cy: feet(y), r: feet(0.22) * s });
+    }
+    // The backstroke flags: a rope across the pool 5 m from each wall, flags of two colours hanging from it.
+    if (plan.flags && !neutral) {
+        for (const x of [SWIMMING.flags.at, L - SWIMMING.flags.at]) {
+            const fx = feet(x);
+            lines += el("path", { class: ft(o, "backstroke-flags", "ky-pl-fa"), d: `M${num(fx)} ${num(feet(-0.6))}V${num(feet(W + 0.6))}`, "stroke-width": feet(0.26) * s, fill: "none", "stroke-dasharray": `${num(feet(0.4))} ${num(feet(0.4))}` });
+            lines += el("path", { class: ft(o, "backstroke-flags", "ky-pl-fb2"), d: `M${num(fx)} ${num(feet(-0.6))}V${num(feet(W + 0.6))}`, "stroke-width": feet(0.26) * s, fill: "none", "stroke-dasharray": `0 ${num(feet(0.4))} ${num(feet(0.4))} 0` });
+            if (full)
+                for (const y of [-0.6, W + 0.6])
+                    lines += el("circle", { class: "ky-pl-st", cx: fx, cy: feet(y), r: feet(0.22) * s });
+        }
+    }
+    // The starting blocks, 0.5 by 0.6 m, one in each lane at each end, numbered on the top (CR 16.2.8 and 16.2.9).
+    if (plan.blocks && !neutral) {
+        const bw = SWIMMING.block.width * s;
+        const bl = SWIMMING.block.length * s;
+        let blocks = "";
+        let numbers = "";
+        for (const lane of plan.lanes) {
+            for (const end of [0, 1]) {
+                const x0 = end === 0 ? -0.08 - bl : L + 0.08;
+                blocks += `M${num(feet(x0))} ${num(feet(lane.y - bw / 2))}h${num(feet(bl))}v${num(feet(bw))}h${num(feet(-bl))}Z`;
+                if (full)
+                    numbers += textOn(o.portrait, feet(x0 + bl / 2), feet(lane.y) + feet(bw) * 0.32, String(lane.number), { size: feet(bw) * 0.72, anchor: "middle", cls: "ky-pl-bn", weight: 800 });
+            }
+        }
+        lines += el("path", { class: ft(o, "starting-blocks", "ky-pl-bk"), d: blocks });
+        lines += numbers;
+    }
+    if (o.landmarks === true) {
+        const top = plan.lanes[0];
+        const mid = plan.lanes[Math.floor(plan.lanes.length / 2)];
+        const ropeY = plan.ropes[1]?.y ?? plan.ropes[0].y;
+        marks.push({ id: "lane-rope", x: feet(L * 0.62), y: feet(ropeY), side: "top" });
+        if (!neutral) {
+            marks.push({ id: "lane-line", x: feet(L * 0.35), y: feet(mid.y), side: "bottom" }, { id: "lane-end-cross", x: feet(SWIMMING.laneLine.endGap), y: feet(top.y), side: "top" }, { id: "fifteen-metre-mark", x: feet(SWIMMING.markAt15), y: 0, side: "top" });
+        }
+        if (plan.pads && !neutral)
+            marks.push({ id: "touch-pad", x: feet(0.15), y: feet(plan.lanes[plan.lanes.length - 1].y), side: "bottom" });
+        if (plan.blocks && !neutral)
+            marks.push({ id: "starting-block", x: feet(-0.6), y: feet(plan.lanes[plan.lanes.length - 1].y), side: "bottom" });
+        if (plan.flags && !neutral)
+            marks.push({ id: "backstroke-flags", x: feet(SWIMMING.flags.at), y: feet(W), side: "bottom" });
+        if (plan.falseStart && !neutral)
+            marks.push({ id: "false-start-rope", x: feet(SWIMMING.falseStart.at), y: feet(W), side: "bottom" });
+        marks.push({ id: "gutter", x: feet(L * 0.8), y: feet(W + GUTTER / 2), side: "bottom" });
+    }
+    return { base, lines, marks, line: lw };
+}
+/**
+ * A swimming pool lying wide with its deck: the body, the deck round it in the colour or the tiles asked for, the data of a race at the walls and over the water, and a side section under the plan if
+ * it is asked for. The pool's water is the surface's `box`; the deck is the margin.
+ */
+export function swimming(o, plan, ctx = {}) {
+    const L = feet(plan.length);
+    const W = feet(plan.width);
+    const ids = ctx.ids ?? poolIds(o.id);
+    const m = ctx.bare === true ? 0 : (o.margin ?? feet(SWIMMING.deck));
+    const body = swimBody(o, plan, ids);
+    const art = ctx.bare === true ? raceArt({ ...plan, race: undefined }, o) : raceArt(plan, o);
+    const section = ctx.bare === true ? sectionOf({ ...plan, section: undefined }, o, 0) : sectionOf(plan, o, W + feet(GUTTER) + m);
+    // The view: the deck all round, the plates at the walls, the title or the distances above, the section below.
+    // The depth of a section is written to the left of it.
+    const left = m + Math.max(art.reachLeft, section.height > 0 ? feet(4) : 0);
+    const right = m + art.reachRight;
+    const topExtra = Math.max(0, art.reachTop, plan.race?.event === undefined ? 0 : feet(1.6));
+    const view0 = { x: -left, y: -m - topExtra, w: L + left + right, h: W + 2 * m + topExtra + (section.height > 0 ? section.height + feet(0.6) : 0) };
+    const defs = ctx.bare === true ? "" : paintDefs(ids, plan.look, plan.deck, plan.seed) + section.defs;
+    const basis = (ctx.bare === true ? "" : deckMarkup(o, ids, plan.deck, view0.x, view0.y, view0.w, view0.h)) + body.base;
+    let lines = body.lines + art.pace + art.left + art.right + art.top;
+    if (section.markup !== "")
+        lines += section.markup;
+    const turned = o.portrait;
+    const cy = W / 2;
+    // How far the blocks reach beyond the walls, in feet.
+    const blockReach = feet(0.08 + SWIMMING.block.length * (o.exact ? 1 : 1.5));
+    const plate = turned ? { cx: L / 2, cy, w: W * 0.9, h: L * 0.34 } : { cx: L / 2, cy, w: L * 0.34, h: W * 0.62 };
+    const surface = {
+        sport: "swimming",
+        view: view0,
+        base: basis,
+        lines,
+        defs,
+        // The teams' names stand on the deck beyond the blocks.
+        left: { cx: -(blockReach + (m - blockReach) / 2), cy, w: W, h: Math.max(1, m - blockReach), rot: -90 },
+        right: { cx: L + blockReach + (m - blockReach) / 2, cy, w: W, h: Math.max(1, m - blockReach), rot: 90 },
+        plate,
+        turned,
+    };
+    surface.box = { x: 0, y: 0, w: L, h: W };
+    surface.lineRef = { width: body.line, feet: 1 };
+    surface.ranges = {
+        half: atEnds((end) => (end === "left" ? edges(0, 0, L / 2, W) : edges(L / 2, 0, L, W))),
+        "pool-end": atEnds((end) => (end === "left" ? edges(0, 0, feet(15), W) : edges(L - feet(15), 0, L, W))),
+    };
+    if (o.landmarks === true)
+        surface.marks = o.detail === "full" ? body.marks : body.marks.filter((mark) => !["lane-end-cross", "fifteen-metre-mark"].includes(mark.id));
+    if (turned) {
+        const t = quarterTurn(view0);
+        surface.view = t.view;
+        surface.turn = t.turn;
+    }
+    return surface;
+}

package/dist/surfaces/skating.d.ts

@@ -0,0 +1,6 @@
+import type { SkatingPlan } from "../skating/plan.ts";
+import { type BuildOptions, type Surface } from "./surface.ts";
+/** Feet in a metre. */
+export declare const K: number;
+/** The surface of the plan lying wide. `margin` is the ground round what is drawn, in feet. */
+export declare function skatingSurface(o: BuildOptions, plan: SkatingPlan, margin: number): Surface;

package/dist/surfaces/skating.js

@@ -0,0 +1,62 @@
+// The skating rink's surface lying wide, from its plan (skating/plan.ts): the ice, the floor of the infield, the warm-up lane, the padding, the boards, the furniture, then every painted line and the
+// blocks. The plan is in metres; the drawing is in feet, as every surface lies, so the whole is drawn inside a group that scales metres to feet and moves the rink's box to the origin.
+import { el } from "../format.js";
+import { areaD, marks, strokes } from "./field.js";
+import { atEnds, edges, ft, quarterTurn } from "./surface.js";
+/** Feet in a metre. */
+export const K = 1 / 0.3048;
+const feetBox = (b, ox, oy) => edges((b.x0 - ox) * K, (b.y0 - oy) * K, (b.x1 - ox) * K, (b.y1 - oy) * K);
+/** A plan's named range in feet, as a surface lists them. */
+function rangeOf(r, ox, oy) {
+    return "left" in r ? atEnds((end) => feetBox(end === "left" ? r.left : r.right, ox, oy)) : feetBox(r, ox, oy);
+}
+/** The surface of the plan lying wide. `margin` is the ground round what is drawn, in feet. */
+export function skatingSurface(o, plan, margin) {
+    const ox = plan.box.x0;
+    const oy = plan.box.y0;
+    const full = o.detail === "full";
+    const view0 = { x: (plan.extent.x0 - ox) * K - margin, y: (plan.extent.y0 - oy) * K - margin, w: (plan.extent.x1 - plan.extent.x0) * K + 2 * margin, h: (plan.extent.y1 - plan.extent.y0) * K + 2 * margin };
+    const place = `scale(${K.toFixed(6)}) translate(${(-ox).toFixed(4)} ${(-oy).toFixed(4)})`;
+    const group = (inner, cls) => el("g", { class: cls, transform: place }, inner);
+    const turned = o.portrait;
+    // Under everything: the apron, then the ice, the floor, the warm-up lane, the padding and the furniture, in the plan's order.
+    let base = el("rect", { class: ft(o, "apron", "ky-apron"), x: view0.x, y: view0.y, width: view0.w, height: view0.h });
+    let ground = "";
+    for (const a of plan.areas)
+        ground += el("path", { class: ft(o, a.feature, a.cls), d: areaD(a), "fill-rule": a.evenodd === true ? "evenodd" : undefined });
+    base += group(ground, "ky-ska-ground");
+    const thick = o.exact ? plan.lineWidth : plan.drawnLine;
+    const lines = group(strokes(plan, o) + marks(plan, o), "ky-ska-lines");
+    const W = (plan.box.x1 - plan.box.x0) * K;
+    const H = (plan.box.y1 - plan.box.y0) * K;
+    const surface = {
+        sport: "skating",
+        view: view0,
+        base,
+        lines,
+        defs: "",
+        // A team's name, in a score, is written on the ice either side of the middle.
+        left: { cx: W * 0.27, cy: H / 2, w: W * 0.2, h: H * 0.11, rot: 0 },
+        right: { cx: W * 0.73, cy: H / 2, w: W * 0.2, h: H * 0.11, rot: 0 },
+        plate: { cx: W / 2, cy: H / 2, w: Math.min(W * 0.34, 140), h: Math.min(W * 0.34, 140) * 0.52 },
+        turned,
+        bannersOver: true,
+        onColour: false,
+    };
+    surface.box = { x: 0, y: 0, w: W, h: H };
+    surface.lineRef = { width: thick, feet: K };
+    const ranges = {};
+    for (const [name, r] of Object.entries(plan.ranges))
+        ranges[name] = rangeOf(r, ox, oy);
+    surface.ranges = ranges;
+    if (o.landmarks === true) {
+        const m = plan.marks.map((p) => ({ id: p.id, x: (p.x - ox) * K, y: (p.y - oy) * K, side: p.side }));
+        surface.marks = full ? m : m.filter((p) => !p.id.startsWith("~"));
+    }
+    if (turned) {
+        const t = quarterTurn(view0);
+        surface.view = t.view;
+        surface.turn = t.turn;
+    }
+    return surface;
+}

package/dist/surfaces/soccer.js

@@ -140,7 +140,7 @@ export function soccer(b, o) {
     // The ends in the team's colour, in a score: the penalty area (or what a small pitch has in its place).
     const zoneDepth = Math.max(spec.penaltyDepth, L * 0.12);
     const zoneWidth = Math.max(spec.area === "arcs" ? spec.areaLine + 2 * spec.penaltyDepth : spec.area === "semicircle" ? 2 * spec.penaltyDepth : lay.penaltyHalfWidth * 2, W * 0.4);
-    if (o.score) {
+    if (o.score && o.pageant !== true) {
         // A rectangle at each end: the penalty area on a full pitch, a box that holds the name on the others (their areas are curved).
         for (const side of [0, 1])
             inside += el("rect", { class: `ky-zone ky-zone-${side === 0 ? "left" : "right"}`, x: side === 0 ? 0 : L - zoneDepth, y: cy - zoneWidth / 2, width: zoneDepth, height: zoneWidth });
@@ -231,6 +231,7 @@ export function soccer(b, o) {
     };
     surface.lineRef = { width: lw, feet: K };
     surface.box = { x: 0, y: 0, w: Lf, h: Wf };
+    surface.centreRadius = spec.centreRadius * K;
     // The penalty area reaches as far as its lines do: the area, the arc beyond it and a small pitch's curved area; and a little more.
     const arcBeyond = spec.arcRadius > 0 && lay.spot > 0 && lay.penaltyDepth > lay.spot ? Math.max(0, spec.arcRadius - (lay.penaltyDepth - lay.spot)) : 0;
     const curved = spec.area === "arcs" || spec.area === "semicircle" ? spec.penaltyDepth : 0;

package/dist/surfaces/surface.d.ts

@@ -1,4 +1,5 @@
 import type { Ballpark } from "../ballpark.ts";
+import type { Hardwood } from "../hardwood.ts";
 import type { Box, Detail, GoalInfo, GoalStyle, Sport, StripePattern } from "../types.ts";
 /** Where a team's name and logo go, and how its words lie. */
 export interface Zone {
@@ -20,6 +21,26 @@ export interface PlateSpot {
     w: number;
     h: number;
 }
+/** A place on a surface for a pageant's picture, in the surface's frame in feet; a `disc` is the diameter of the round room the picture must lie in (a curling house). */
+export interface PageantSpot extends PlateSpot {
+    disc?: number;
+}
+/** What a surface says of where a pageant's pictures go, when it is not the plain halves and the middle. */
+export interface PageantPlan {
+    /** Where the first (left) team's picture goes, and the second's (right), when not in the halves: a diamond's outfield and infield, a sheet's two houses. */
+    left?: PageantSpot;
+    right?: PageantSpot;
+    /** The emblem's place: its centre and the radius of the circle it lies in; the middle of the surface, with the centre circle's radius, when missing. */
+    centre?: {
+        cx: number;
+        cy: number;
+        r: number;
+    };
+    /** Half the length, along the surface, that the pictures keep clear in the middle (a cricket pitch's). */
+    clear?: number;
+    /** The first picture is the away team's and the second the home team's, whichever side each is on (a diamond's outfield is the visitors', its infield the home team's). */
+    byRole?: boolean;
+}
 /** The parts of a surface a drawing can be cropped to, by name: one box, or one at each end (`left` and `right` as the surface lies wide), in feet in the wide frame. */
 export type SurfaceRanges = Readonly<Record<string, Box | {
     left: Box;
@@ -84,11 +105,28 @@ export interface Surface {
     plateFits?: boolean;
     /** For a surface set inside another (a special game): the transform that carries the surface's own frame to the drawing's, which data in the surface's frame (`layers`) is put through. */
     frame?: string;
+    /** A surface drawn in parts, one of which is shown again larger beside it (a folded curling sheet): for each copy, the transform that carries the surface's frame to it and the id of the clip that cuts it. The data layers are drawn in each. */
+    panels?: {
+        transform: string;
+        clip: string;
+    }[];
+    /** Markup drawn over the data layers: the labels of a surface's panels. */
+    over?: string;
+    /** True for a surface whose frame has parts the annotations (axes, direction, landmarks) have no margin to stand in. */
+    folded?: boolean;
+    /** The radius of the centre circle in feet, where the surface has one: the emblem of a pageant lies in it. */
+    centreRadius?: number;
+    /** Where a pageant's pictures go, when the halves and the middle are not the place. */
+    pageant?: PageantPlan;
+    /** For a surface whose own frame is turned to an angle that is not a quarter (a close-up of an athletics start): the turn, in degrees, that a layer's texts and logos are given to read upright. */
+    upright?: number;
     /** How wide the surface's ordinary line is drawn, in the units of the `lines` markup, and how many feet one of those units is: what `lineWidth` scales. */
     lineRef?: {
         width: number;
         feet: number;
     };
+    /** For a surface with a crowd: the margin it was drawn with, which holds the stands. */
+    crowdMargin?: number;
 }
 /** A part of a surface to label: its anchor on the surface in feet and the margin its label stands in (the top or the bottom as the surface lies wide). */
 export interface Mark {
@@ -114,9 +152,15 @@ export interface BuildOptions {
         baselineText?: [string, string];
         centreLogo?: string;
         paintThreePoint?: boolean;
+        /** The realistic floor, when asked for (`court.hardwood`), its options read. */
+        hardwood?: Hardwood;
+        /** Words along the sidelines, `[top, bottom]`, on a hardwood floor. */
+        sidelineText?: [string, string];
     };
     /** True in a score drawing, so that panels are made room for. */
     score: boolean;
+    /** True when the drawing is a pageant: the teams' pictures lie over the halves, so the ends are not painted in the teams' colours. */
+    pageant?: boolean;
     /** The names of the features that have a colour of their own, so that their elements carry the class that colour is given to. */
     features?: ReadonlySet<string>;
     /** How the grass is mown, when the options say (a football field and a ballpark have their own default). */

package/dist/surfaces/venue.d.ts

@@ -0,0 +1,15 @@
+import { type VenueLayout } from "../pool.ts";
+import type { Language, PoolStyle } from "../types.ts";
+import { type BuildOptions, type Surface } from "./surface.ts";
+/** The name each pool of a hall is called on the plan, in a language. */
+export declare function venueName(item: VenueLayout["items"][number], language: Language): string;
+/**
+ * Several pools in one hall, to scale: each pool is drawn by its own sport's builder (the competition pool of 8 lanes, a diving well, a warm-up pool, a water polo pool or an artistic swimming area) and set at its place,
+ * with the deck round the hall drawn once and the paint of the water and the deck defined once for all of them. The pools stand at least 8 m apart, 10 m by default, as the rules keep a swimming pool and a diving well
+ * (CR 16.2.17). The water of the whole hall is the surface's `box`.
+ */
+export declare function natatorium(o: BuildOptions, style: PoolStyle, look: {
+    look: "flat" | "water" | "tiled";
+    deck: "plain" | "tiled";
+    seed: number;
+}, language: Language): Surface;

package/dist/surfaces/venue.js

@@ -0,0 +1,95 @@
+import { el, num } from "../format.js";
+import { feet, reachOf, venueLayout } from "../pool.js";
+import { deckMarkup, paintDefs, poolIds } from "../pool.kit.js";
+import { KYOGIJO_STRINGS } from "../strings.js";
+import { artistic } from "./artistic.js";
+import { diving } from "./dive.js";
+import { swimming } from "./pool.js";
+import { waterPolo } from "./polo.js";
+import { quarterTurn, textOn } from "./surface.js";
+/** One pool of a hall drawn on its own with no deck: the surface its sport's builder makes. */
+function built(o, plan, ctx) {
+    switch (plan.sport) {
+        case "swimming":
+            return swimming(o, { ...plan, race: undefined, section: undefined }, ctx);
+        case "waterpolo":
+            return waterPolo(o, plan, ctx);
+        case "diving":
+            return diving(o, plan, ctx);
+        default:
+            return artistic(o, plan, ctx);
+    }
+}
+/** The name each pool of a hall is called on the plan, in a language. */
+export function venueName(item, language) {
+    if (item.pool.name !== undefined)
+        return item.pool.name;
+    const names = KYOGIJO_STRINGS[language].pool.names;
+    const plan = item.plan;
+    return plan.sport === "swimming" ? (plan.kind === "warm-up" ? names.warmUp : names.competition) : plan.sport === "diving" ? names.diving : plan.sport === "waterpolo" ? names.waterPolo : names.artistic;
+}
+/**
+ * Several pools in one hall, to scale: each pool is drawn by its own sport's builder (the competition pool of 8 lanes, a diving well, a warm-up pool, a water polo pool or an artistic swimming area) and set at its place,
+ * with the deck round the hall drawn once and the paint of the water and the deck defined once for all of them. The pools stand at least 8 m apart, 10 m by default, as the rules keep a swimming pool and a diving well
+ * (CR 16.2.17). The water of the whole hall is the surface's `box`.
+ */
+export function natatorium(o, style, look, language) {
+    const layout = venueLayout(style);
+    const ids = poolIds(o.id);
+    const m = o.margin ?? feet(3.5);
+    const W = feet(layout.width);
+    const H = feet(layout.height);
+    const label = 3.2;
+    const labelRoom = layout.labels ? feet(3.4) : 0;
+    const reach = layout.reach;
+    // The hall inside its walls: the water of every pool, what stands beyond it, the deck round it and the names under the pools.
+    const hall = { x: -feet(reach.left) - m, y: -feet(reach.top) - m, w: W + feet(reach.left + reach.right) + 2 * m, h: H + feet(reach.top + reach.bottom) + 2 * m + labelRoom };
+    const seats = layout.seating ? feet(6) : 0;
+    const rim = m * 0.4;
+    const view0 = { x: hall.x - rim, y: hall.y - seats - (layout.seating ? feet(1) : 0) - rim, w: hall.w + 2 * rim, h: hall.h + seats + (layout.seating ? feet(1) : 0) + 2 * rim };
+    let base = deckMarkup(o, ids, look.deck, view0.x, view0.y, view0.w, view0.h);
+    base += el("rect", { class: "ky-pl-hw", x: hall.x, y: hall.y, width: hall.w, height: hall.h });
+    if (layout.seating) {
+        const top = hall.y - feet(1) - seats;
+        let rows = "";
+        for (let r = 1; r < 6; r += 1)
+            rows += `M${num(hall.x)} ${num(top + (seats * r) / 6)}H${num(hall.x + hall.w)}`;
+        base += el("rect", { class: "ky-pl-seat", x: hall.x, y: top, width: hall.w, height: seats });
+        base += el("path", { class: "ky-pl-rows", d: rows });
+    }
+    let lines = "";
+    let names = "";
+    for (const [i, item] of layout.items.entries()) {
+        const child = built({ ...o, margin: 0, score: false, landmarks: false, portrait: false, id: `${o.id}-${i}` }, item.plan, { ids, bare: true });
+        const move = `translate(${num(feet(item.x))} ${num(feet(item.y))})`;
+        base += el("g", { class: "ky-pl-hall", transform: move }, child.base);
+        lines += el("g", { class: "ky-pl-hall", transform: move }, child.lines);
+        if (layout.labels) {
+            const below = feet(item.y + item.plan.width + reachOf(item.plan).bottom);
+            names += textOn(o.portrait, feet(item.x + item.plan.length / 2), below + feet(1.2) + label * 0.36, venueName(item, language), { size: label, anchor: "middle", cls: "ky-pl-vn", weight: 800 });
+        }
+    }
+    if (layout.seating)
+        names += textOn(o.portrait, hall.x + hall.w / 2, hall.y - feet(1) - seats / 2 + label * 0.36, KYOGIJO_STRINGS[language].pool.names.seating, { size: label, anchor: "middle", cls: "ky-pl-vn", weight: 800 });
+    const cy = H / 2;
+    const turned = o.portrait;
+    const surface = {
+        sport: "swimming",
+        view: view0,
+        base,
+        lines: lines + names,
+        defs: paintDefs(ids, look.look, look.deck, look.seed),
+        left: { cx: hall.x + m / 2, cy, w: H, h: m, rot: -90 },
+        right: { cx: hall.x + hall.w - m / 2, cy, w: H, h: m, rot: 90 },
+        plate: turned ? { cx: W / 2, cy, w: H * 0.8, h: W * 0.3 } : { cx: W / 2, cy, w: W * 0.3, h: H * 0.4 },
+        turned,
+    };
+    surface.box = { x: 0, y: 0, w: W, h: H };
+    surface.lineRef = { width: 0.8, feet: 1 };
+    if (turned) {
+        const t = quarterTurn(view0);
+        surface.view = t.view;
+        surface.turn = t.turn;
+    }
+    return surface;
+}

package/dist/tenants.d.ts

@@ -0,0 +1,77 @@
+/** The sport a tenant plays: what decides the surface a place offers for it (`surfaceOf`). */
+export type TenantSport = "baseball" | "soccer" | "american-football" | "canadian-football" | "basketball" | "ice-hockey" | "rugby-union" | "rugby-league" | "australian-football" | "lacrosse" | "cricket";
+/** The article of English Wikipedia, at a revision, that a place's tenants were read from. */
+export interface TenantArticle {
+    title: string;
+    revision: number;
+}
+/** Where a tenant was read. */
+export interface TenantSource {
+    /** The Wikidata statement that names the club as a tenant (CC0): `P466` (the place lists the club as an occupant), `P115` (the club lists the place as its home venue), or both. Absent where only the article names it. */
+    wikidata?: "P466" | "P115" | "P466 P115";
+    /** The article and revision of English Wikipedia (CC BY-SA 4.0) whose `tenants` line in the place's infobox lists the club. Absent where only Wikidata names it. */
+    wikipedia?: TenantArticle;
+    /** Where the years were read: Wikidata's qualifiers (start time P580, end time P582), or the article. Absent when neither gives any. */
+    years?: "wikidata" | "wikipedia";
+}
+/** Why a club's name in Japanese is not Wikidata's label: the label is a transliteration of an abbreviation (`abbreviation`), of a formal name or a suffix such as FC that Japanese media do not use (`formal`), a page title with a disambiguator or "history of" (`title`), or the club's name in another period (`era`). */
+export type TenantNameKind = "abbreviation" | "formal" | "title" | "era";
+/** The everyday Japanese form of a club's name where it is not Wikidata's label, and the source of it. */
+export interface TenantNameJa {
+    /** The name Japanese media use, which the atlas shows as `clubJa`. */
+    ja: string;
+    kind: TenantNameKind;
+    /** What was checked, where and when. */
+    note: string;
+}
+/** A tenant as the data gives it. */
+export interface TenantData {
+    club: string;
+    clubJa?: string;
+    aliasesJa?: string[];
+    league: string;
+    sport: TenantSport;
+    from?: number;
+    to?: number;
+    wikidata: string;
+    statements?: "P466" | "P115" | "P466 P115";
+    /** The place's article lists the club in its tenants line. */
+    listed?: true;
+    years?: "wikidata" | "wikipedia";
+}
+/** A club that plays, or played, its home matches in a place, and when. */
+export interface Tenant {
+    /** The club's name in English: the one the place's article gives it (`Montreal Expos`, `Boston Braves` for a club named differently then), else Wikidata's label. */
+    club: string;
+    /** The club's name in Japanese as Japanese media say it (`BCライオンズ`), where there is one for this name of the club: the curated form in `TENANT_NAMES_JA` if the club has one, else Wikidata's label. */
+    clubJa?: string;
+    /** Other names the club is found by in Japanese: Wikidata's label where `clubJa` is the curated form instead (`ブリティッシュ・コロンビア・ライオンズ`). */
+    aliasesJa?: readonly string[];
+    /** The league it played in there: `MLB`, `CFL`, `MLS`, `NPB`, `Premier League`... A league that has had several names or several seasons of the same name has one (`NASL` is the league of 1968 to 1984). */
+    league: string;
+    sport: TenantSport;
+    /** The first year it played there. Not given where neither source gives it. */
+    from?: number;
+    /** The last year it played there: a club still there has none. */
+    to?: number;
+    /** The club's Wikidata item (`Q919062`), the key to join a tenant to other data. */
+    wikidata: string;
+    source: TenantSource;
+}
+/** The tenants of every place that has any, by the place's key: the current ones first, by the year they came, then those that have left, the latest to leave first. */
+export declare const TENANTS: Readonly<Record<string, readonly Tenant[]>>;
+/** The leagues of a list of tenants, each once, in the order they first come. */
+export declare const leaguesOf: (tenants: readonly Tenant[]) => string[];
+/** True when a tenant played there in `year`; a year the data does not give for a bound does not shut it out. */
+export declare const playedIn: (tenant: Tenant, year: number) => boolean;
+/** The draw sport a tenant's sport is drawn as, and any league of its rulebook: the field of play a club's sport asks for. `undefined` where the package draws none. */
+export declare const SURFACE_OF_SPORT: Readonly<Record<TenantSport, {
+    sport: "mlb" | "soccer" | "nfl" | "cfl" | "nba" | "nhl" | "rugby" | "afl" | "cricket";
+    league?: "nrl";
+} | undefined>>;
+/** True when the package draws a surface for the tenant's sport and league. */
+export declare const hasSurface: (tenant: Tenant) => boolean;
+/** The clubs whose name in Japanese is the everyday form and not Wikidata's label, by Wikidata item, with why and the source of each: `nameJaOf(tenant)` finds a tenant's. */
+export declare const TENANT_JAPANESE_NAMES: Readonly<Record<string, TenantNameJa>>;
+/** The note on a tenant's name in Japanese, if its everyday form is a curated one. */
+export declare const nameJaOf: (tenant: Pick<Tenant, "wikidata">) => TenantNameJa | undefined;

package/dist/tenants.data.d.ts

@@ -0,0 +1,8 @@
+import type { TenantArticle, TenantData, TenantNameJa } from "./tenants.ts";
+/** The article of English Wikipedia, at the revision read, that the tenants of a place are listed in. */
+export declare const TENANT_ARTICLES: Readonly<Record<string, TenantArticle>>;
+/** The leagues whose field or court is not the one the package draws for their sport (arena football, a basketball league that played on another court): their clubs ask for no surface. */
+export declare const TENANT_NO_SURFACE: readonly string[];
+/** The clubs whose name in Japanese is not Wikidata's label, by the club's Wikidata item: the everyday form, why Wikidata's label is not it, and the source of each. See scripts/tenants.names-ja.json. */
+export declare const TENANT_NAMES_JA: Readonly<Record<string, TenantNameJa>>;
+export declare const TENANT_DATA: Readonly<Record<string, TenantData[]>>;