@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.6.0

package/dist/team.lineup.d.ts

@@ -0,0 +1,27 @@
+import { type Env, type Made } from "./layers.env.ts";
+import { type Spot } from "./team.formation.ts";
+import { type TeamTable } from "./team.common.ts";
+import type { Formation, FormationLayer, LineupLayer, LineupPlayer } from "./team.types.ts";
+/** How wide a text is, in ems of a bold sans-serif face, by a rough count: wide for Japanese and capitals, narrow for the letters that are. */
+export declare function textWidth(text: string): number;
+/** A name cut to fit `ems` of width, with an ellipsis; nothing when not even three letters fit. */
+export declare function fit(name: string, ems: number): string;
+/** The jersey as a path through its corners, `size` wide, centred on `(x, y)`: sleeves, shoulders, a neckline and the body. */
+export declare function jerseyPath(x: number, y: number, size: number): string;
+/** The formation a lineup is drawn in, and how the players stand in it. */
+export interface Lineup {
+    formation: Formation;
+    /** The layer as a formation layer: the players put on the places they were given. */
+    layer: FormationLayer;
+    spots: Spot[];
+    /** The players with no place in the formation. */
+    unplaced: LineupPlayer[];
+    /** The player standing on each place, with everything the lineup knows of him. */
+    stands: Map<string, LineupPlayer>;
+}
+/** The formation a lineup uses: the one named, one of your own, or the best fit among those of the surface's sport (the softball one for a softball field). */
+export declare function lineupFormation(layer: LineupLayer, env: Env): Formation;
+/** A lineup's places on the surface and the players on them. */
+export declare function computeLineup(layer: LineupLayer, env: Env): Lineup;
+export declare function drawLineup(layer: LineupLayer, env: Env): Made;
+export declare function lineupTables(layer: LineupLayer, env: Env): TeamTable[];

package/dist/team.lineup.js

@@ -0,0 +1,207 @@
+// The lineup layer: a team's players placed by position code on the surface, each as a disc or a jersey with the shirt number in it and the name under it, with a captain's
+// armband and a small flag where they are given. It reads where each position stands from a formation (formations.ts, formations.sports.ts) and so needs no coordinates; two
+// teams are two layers. Written for this package.
+import { safeLogo } from "./logo.js";
+import { esc, num } from "./format.js";
+import { FRAMES } from "./frames.js";
+import { positionName } from "./formations.js";
+import { assign, bestFormation, formationsFor, spotsOf } from "./lineup.codes.js";
+import { isNum, newMade, opacityOf, unitOfLayer } from "./layers.env.js";
+import { chooseLeague } from "./leagues.js";
+import { SURFACES, computeFormation, formationOf } from "./team.formation.js";
+import { attrs, labelOf, paintOf, round, titled } from "./team.common.js";
+import { fill } from "./strings.js";
+import { FEET_PER } from "./units.js";
+/** The sports whose team turns round for the visitors: a side that attacks the other end. Baseball's fielders, football's offence and a cricket field do not. */
+const TURNS = new Set(["soccer", "nhl", "nba", "rugby", "afl", "volleyball", "handball", "waterpolo", "fieldhockey", "netball"]);
+/** How wide a text is, in ems of a bold sans-serif face, by a rough count: wide for Japanese and capitals, narrow for the letters that are. */
+export function textWidth(text) {
+    let width = 0;
+    for (const ch of text) {
+        const code = ch.codePointAt(0) ?? 0;
+        if (code >= 0x2e80)
+            width += 1;
+        else if ("iljtfI.,:;'!| ()".includes(ch))
+            width += 0.32;
+        else if (/[A-Z0-9MWmw@%]/.test(ch))
+            width += 0.7;
+        else
+            width += 0.6;
+    }
+    return width;
+}
+/** A name cut to fit `ems` of width, with an ellipsis; nothing when not even three letters fit. */
+export function fit(name, ems) {
+    if (textWidth(name) <= ems)
+        return name;
+    const letters = [...name];
+    while (letters.length > 0 && textWidth(`${letters.join("").trimEnd()}…`) > ems)
+        letters.pop();
+    return letters.length < 3 ? "" : `${letters.join("").trimEnd()}…`;
+}
+/** The jersey as a path through its corners, `size` wide, centred on `(x, y)`: sleeves, shoulders, a neckline and the body. */
+export function jerseyPath(x, y, size) {
+    const p = (dx, dy) => `${num(x + dx * size)} ${num(y + dy * size)}`;
+    return `M${p(-0.17, -0.48)}Q${p(0, -0.36)} ${p(0.17, -0.48)}L${p(0.5, -0.3)}L${p(0.42, -0.02)}L${p(0.34, -0.07)}L${p(0.34, 0.48)}L${p(-0.34, 0.48)}L${p(-0.34, -0.07)}L${p(-0.42, -0.02)}L${p(-0.5, -0.3)}Z`;
+}
+/** The formation a lineup uses: the one named, one of your own, or the best fit among those of the surface's sport (the softball one for a softball field). */
+export function lineupFormation(layer, env) {
+    if (!Array.isArray(layer.players))
+        throw new TypeError("a lineup needs players: a list of { pos, name, number }");
+    if (layer.formation !== undefined)
+        return formationOf({ kind: "formation", formation: layer.formation });
+    const sports = Object.keys(SURFACES).filter((sport) => SURFACES[sport].includes(env.o.sport));
+    const softball = (() => { const league = chooseLeague(env.o).league; return league?.family === "baseball" && league.game === "softball"; })();
+    const among = formationsFor(sports).filter((f) => (f.id === "softball-standard") === softball);
+    const best = bestFormation(among, layer.players, layer.rotation);
+    if (best === undefined)
+        throw new RangeError(`There is no formation for ${env.o.sport}: give the formation of your own`);
+    return best;
+}
+/** A lineup's places on the surface and the players on them. */
+export function computeLineup(layer, env) {
+    const formation = lineupFormation(layer, env);
+    const f = formationOf({ kind: "formation", formation });
+    const spotsList = spotsOf(f);
+    const made = assign(f, layer.players, layer.rotation);
+    const stands = new Map();
+    const unplaced = [];
+    const data = [];
+    layer.players.forEach((p, i) => {
+        const id = made.of[i];
+        if (id === undefined || typeof p !== "object" || p === null) {
+            if (typeof p === "object" && p !== null)
+                unplaced.push(p);
+            return;
+        }
+        stands.set(id, p);
+        data.push({ ...p, position: id, team: p.team ?? layer.side ?? "home" });
+    });
+    const side = layer.side === "away" ? "away" : "home";
+    // The visitors attack the other end, except where the sport does not turn: a football offence goes right unless the layer says, and a defence faces it.
+    const attacking = layer.attacking ?? (side === "away" && TURNS.has(env.o.sport) ? "left" : undefined);
+    const asLayer = { ...layer, kind: "formation", formation: { ...f, positions: spotsList, extra: undefined }, team: side, data, attacking, labels: undefined, names: undefined, size: layer.size };
+    const { spots } = computeFormation(asLayer, env);
+    return { formation, layer: asLayer, spots, unplaced, stands };
+}
+const NUMBER_INK = "ky-nm";
+export function drawLineup(layer, env) {
+    const made = newMade();
+    const words = env.words.team;
+    const language = env.o.language === "ja" ? "ja" : "en";
+    const { formation, spots, unplaced, stands } = computeLineup(layer, env);
+    const k = FEET_PER[unitOfLayer(layer, env)];
+    const rel = new Map(spotsOf(formation).map((p) => [p.id, p.size ?? 1]));
+    // The marks are as big as is usual and no bigger than the first line's places allow; the second line's are smaller.
+    const first = spots.filter((s) => (rel.get(s.id) ?? 1) >= 1);
+    let nearest = Infinity;
+    first.forEach((a, i) => first.forEach((b, j) => (j > i ? (nearest = Math.min(nearest, Math.hypot(a.at[0] - b.at[0], a.at[1] - b.at[1]))) : undefined)));
+    // A football line stands shoulder to shoulder, so sizing by the nearest neighbour would shrink the offence and not the defence: both teams get one size.
+    const football = env.o.sport === "nfl" || env.o.sport === "ifaf";
+    const base = isNum(layer.size) && layer.size > 0 ? layer.size * k : football ? env.base * 2.4 : Math.min(env.base * 3.4, Math.max(env.base * 2, (Number.isFinite(nearest) ? nearest : env.base * 2) * 0.9));
+    const jersey = layer.shape === "jersey";
+    const mode = layer.labels === "position" || layer.labels === "number" || layer.labels === "name" || layer.labels === "none" ? layer.labels : "number";
+    const showNames = layer.names !== false && mode !== "name";
+    const side = layer.side === "away" ? "away" : "home";
+    const mine = paintOf({ team: side });
+    const marks = [];
+    const badges = [];
+    const text = [];
+    spots.forEach((s) => {
+        const player = stands.get(s.id);
+        const size = base * (rel.get(s.id) ?? 1);
+        const [cx, cy] = s.at;
+        const own = paintOf(player === undefined ? undefined : { color: player.color, team: player.team ?? side });
+        const cls = [own.cls !== "" ? own.cls : mine.cls, player === undefined ? "ky-e" : ""].filter((c) => c !== "").join(" ");
+        const tip = [s.name, player === undefined ? "" : [player.name, player.number].filter((t) => t !== undefined && t !== "").join(" ")].filter((t) => t !== "").join(env.words.said.colon);
+        const turn = env.turned ? ` transform="rotate(-90 ${num(cx)} ${num(cy)})"` : "";
+        marks.push(titled(jersey ? "path" : "circle", `${attrs(cls, own.css)} ${jersey ? `d="${jerseyPath(cx, cy, size * 1.08)}"` : `cx="${num(cx)}" cy="${num(cy)}" r="${num(size / 2)}"`}`, player?.title ?? tip));
+        // What is in the mark.
+        let label = "";
+        if (mode === "position")
+            label = s.id;
+        else if (mode === "number")
+            label = player === undefined ? s.id : player.number === undefined || player.number === "" ? s.id : String(player.number);
+        else if (mode === "name")
+            label = player === undefined ? s.id : labelOf(player);
+        if (label !== "") {
+            const room = jersey ? size * 0.6 : size * 0.86;
+            const fs = Math.min(size * 0.46, room / Math.max(0.9, textWidth(label)));
+            text.push(`<text class="${player === undefined ? "ky-lt" : NUMBER_INK}" style="font-size:${num(fs)}px" x="${num(cx)}" y="${num(cy + fs * 0.36 + (jersey ? size * 0.07 : 0))}"${turn}>${esc(label)}</text>`);
+        }
+        // The name, under the mark, as wide as the neighbours allow and no wider: it shrinks, and is squeezed if it must be.
+        if (showNames && player?.name !== undefined && player.name !== "") {
+            let neighbour = Infinity;
+            for (const other of spots)
+                if (other !== s)
+                    neighbour = Math.min(neighbour, Math.hypot(other.at[0] - cx, other.at[1] - cy));
+            const room = Math.max(size * 1.05, Math.min(size * 3.4, (Number.isFinite(neighbour) ? neighbour : size * 3) * 0.92));
+            // The name shrinks to fit, down to a quarter of the mark's width; a name still too long is cut short with an ellipsis, and one that cannot keep three letters is left out
+            // (a football line stands shoulder to shoulder). The whole name is in the tooltip, the description and the table.
+            const fs = Math.min(size * 0.4, Math.max(size * 0.26, room / textWidth(player.name)));
+            const shown = fit(player.name, room / fs);
+            if (shown !== "")
+                text.push(`<text class="ky-lt" style="font-size:${num(fs)}px" x="${num(cx)}" y="${num(cy + size * (jersey ? 0.54 : 0.5) + fs * 1.05)}"${turn}>${esc(shown)}</text>`);
+        }
+        // The captain's armband and the flag.
+        if (player?.captain === true) {
+            const r = size * 0.2;
+            const bx = cx - size * 0.4;
+            const by = cy - size * 0.4;
+            badges.push(titled("circle", ` class="ky-lc" cx="${num(bx)}" cy="${num(by)}" r="${num(r)}"`, words.captainTip));
+            text.push(`<text class="ky-cl" style="font-size:${num(r * 1.25)}px" x="${num(bx)}" y="${num(by + r * 0.45)}"${env.turned ? ` transform="rotate(-90 ${num(bx)} ${num(by)})"` : ""}>${esc(words.captainMark)}</text>`);
+        }
+        const flag = safeLogo(player?.flag);
+        if (flag !== undefined) {
+            const h = size * 0.3;
+            const w = h * 1.5;
+            const fx = cx + size * 0.42 - w / 2;
+            const fy = cy + size * 0.4 - h / 2;
+            const spin = env.turned ? ` transform="rotate(-90 ${num(fx + w / 2)} ${num(fy + h / 2)})"` : "";
+            badges.push(`<g${spin}><image href="${esc(flag)}" x="${num(fx)}" y="${num(fy)}" width="${num(w)}" height="${num(h)}" preserveAspectRatio="xMidYMid slice"/><rect class="ky-lf" x="${num(fx)}" y="${num(fy)}" width="${num(w)}" height="${num(h)}"/></g>`);
+        }
+    });
+    made.drawn = spots.length;
+    made.skipped = unplaced.length;
+    made.cls = "ky-tm";
+    made.opacity = opacityOf(layer.opacity);
+    made.style = `--w:${num(base * 0.07)}`;
+    made.marks = `<g class="ky-fm${mine.cls === "" ? "" : ` ${mine.cls}`}">${marks.join("")}</g>${badges.length === 0 ? "" : `<g class="ky-lb">${badges.join("")}</g>`}<g text-anchor="middle">${text.join("")}</g>`;
+    const name = formation.name[language];
+    made.title = fill(words.lineupTitle, { name, n: stands.size });
+    const parts = [];
+    const list = spots.filter((s) => stands.has(s.id)).map((s) => fill(words.formationItem, { who: labelOf(stands.get(s.id)) || s.id, position: s.name }));
+    if (list.length > 0)
+        parts.push(fill(words.formationPlayers, { list: list.join(env.words.layers.listSep) }));
+    const captain = [...stands.values()].find((p) => p.captain === true);
+    if (captain !== undefined)
+        parts.push(fill(words.lineupCaptain, { who: labelOf(captain) }));
+    if (formation.sport === "volleyball" && isNum(layer.rotation) && layer.rotation >= 1)
+        parts.push(fill(words.lineupRotation, { n: Math.floor(layer.rotation) }));
+    if (unplaced.length > 0)
+        parts.push(fill(words.lineupUnplaced, { list: unplaced.map((p) => labelOf(p) || String(p.pos)).join(env.words.layers.listSep) }));
+    parts.push(formation.about[language]);
+    made.text = parts.join(env.words.said.gap);
+    return made;
+}
+export function lineupTables(layer, env) {
+    const w = env.words.team;
+    const l = env.words.layers;
+    const { formation, spots, unplaced, stands } = computeLineup(layer, env);
+    const language = env.o.language === "ja" ? "ja" : "en";
+    const frame = FRAMES[formation.frame];
+    const yes = w.captainMark;
+    const rows = spots.map((s, i) => {
+        const p = stands.get(s.id);
+        return [i + 1, s.id, s.name, p?.number === undefined ? null : String(p.number), p?.name ?? null, p === undefined ? null : p.captain === true ? yes : null, round(s.given[0], 2), round(s.given[1], 2)];
+    });
+    unplaced.forEach((p, i) => rows.push([spots.length + i + 1, String(p.pos), positionName(formation.sport, String(p.pos), language), p.number === undefined ? null : String(p.number), p.name ?? null, p.captain === true ? yes : null, null, null]));
+    return [
+        {
+            head: [l.tableNo, w.tablePosition, w.tableName, w.tableNumber, w.tablePlayer, w.tableCaptain, l.tableX, l.tableY],
+            rows,
+            title: typeof layer.title === "string" && layer.title !== "" ? layer.title : fill(w.lineupTitle, { name: formation.name[language], n: stands.size }),
+            note: fill(l.tableFrame, { frame: formation.frame, unit: frame.unit }),
+        },
+    ];
+}

package/dist/team.network.js

@@ -2,7 +2,7 @@
 // players sized and shaded by the passes between them. Written for this package from the plain arithmetic of counting and averaging; the idea
 // is that of mplsoccer's pass-network example (MIT), and no code of it is used.
 import { esc, num } from "./format.js";
-import { isNum, newMade, opacityOf, place, toArray, unitOfLayer } from "./layers.env.js";
+import { isNum, markAttrs, newMade, opacityOf, place, toArray, unitOfLayer } from "./layers.env.js";
 import { curveBetween, curvePath, headPath } from "./layers.marks.js";
 import { fill } from "./strings.js";
 import { attrs, frameNote, round, teamClass, teamKey, titled } from "./team.common.js";
@@ -151,21 +151,22 @@ export function drawNetwork(layer, env) {
         const cls = teamClass(l.team);
         const o = between(alpha, linkT(l), false);
         const names = { a: nodeName(l.a), b: nodeName(l.b), n: l.n };
+        const link = !env.marks ? "" : ` data-mark-id="${esc(`${idText(l.a.id)}-${idText(l.b.id)}`)}" data-index="${links.length}" data-from="${esc(idText(l.a.id))}" data-to="${esc(idText(l.b.id))}"`;
         if (net.directed) {
             const curve = curveBetween(a, b, 0.14);
             const hl = Math.max(w * 3.4, base * 0.9);
             const stop = nodeWidth(l.b) / 2;
             const shaft = curve.trim(stop + hl * 0.9);
             const head = headPath(curve.at(Math.max(0, curve.length - stop)), curve.tangent(Math.max(0, curve.length - stop)), hl, hl * 0.5, false);
-            links.push(`<g${attrs(cls, "", o)}><title>${esc(fill(words.linkTitleDirected, names))}</title><path class="ky-ln" stroke-width="${num(w)}" d="${curvePath(shaft)}"/><path class="ky-ah" d="${head}"/></g>`);
+            links.push(`<g${attrs(cls, "", o)}${link}><title>${esc(fill(words.linkTitleDirected, names))}</title><path class="ky-ln" stroke-width="${num(w)}" d="${curvePath(shaft)}"/><path class="ky-ah" d="${head}"/></g>`);
         }
         else
-            links.push(titled("path", `${attrs(`ky-ln${cls === "" ? "" : ` ${cls}`}`, "", o)} stroke-width="${num(w)}" d="M${num(a[0])} ${num(a[1])}L${num(b[0])} ${num(b[1])}"`, fill(words.linkTitle, names)));
+            links.push(titled("path", `${attrs(`ky-ln${cls === "" ? "" : ` ${cls}`}`, "", o)}${link} stroke-width="${num(w)}" d="M${num(a[0])} ${num(a[1])}L${num(b[0])} ${num(b[1])}"`, fill(words.linkTitle, names)));
     }
-    const nodes = net.nodes.map((n) => {
+    const nodes = net.nodes.map((n, index) => {
         const at = n.at;
         const cls = teamClass(n.team);
-        return titled("circle", `${attrs(cls, "")} cx="${num(at[0])}" cy="${num(at[1])}" r="${num(nodeWidth(n) / 2)}"`, fill(words.nodeTitle, { name: nodeName(n), touches: n.touches, made: n.made, received: n.received }));
+        return titled("circle", `${attrs(cls, "")} cx="${num(at[0])}" cy="${num(at[1])}" r="${num(nodeWidth(n) / 2)}"${markAttrs(env, idText(n.id), index, [at[0], at[1]])}`, fill(words.nodeTitle, { name: nodeName(n), touches: n.touches, made: n.made, received: n.received }));
     });
     const mode = layer.labels === "name" || layer.labels === "id" || layer.labels === "none" || layer.labels === "number" ? layer.labels : "number";
     const text = [];

package/dist/team.shape.js

@@ -2,7 +2,7 @@
 // is near whom) and the convex hull (how much ground the team covers). Written for this package from the plain geometry of team.geometry.ts;
 // the ideas are those of mplsoccer's Voronoi, Delaunay and convex-hull examples (MIT), and no code of it is used.
 import { num } from "./format.js";
-import { opacityOf, newMade, toArray, unitOfLayer } from "./layers.env.js";
+import { markAttrs, opacityOf, newMade, toArray, unitOfLayer } from "./layers.env.js";
 import { attrs, dots, frameNote, squareWord, unitWord, groupByTeam, paintOf, placeAll, polygonPath, round, teamClass, teamKey, teamLabel, titled, labelOf } from "./team.common.js";
 import { convexHull, delaunay, polygonArea, polygonCentroid, triangulationEdges, voronoiCells } from "./team.geometry.js";
 import { fill } from "./strings.js";
@@ -72,10 +72,10 @@ export function drawVoronoi(layer, env) {
         if (c.cells[i].length === 0)
             return;
         const { cls, css } = paintOf(p.d);
-        out.push(titled("path", `${attrs(`ky-sp${cls === "" ? "" : ` ${cls}`}`, css)} d="${polygonPath(c.cells[i])}"`, `${[who(p), teamKey(p.d.team) === "" ? "" : teamLabel(teamKey(p.d.team), env)].filter((t) => t !== "").join(", ")}: ${round(100 * c.shares[i])}%`));
+        out.push(titled("path", `${attrs(`ky-sp${cls === "" ? "" : ` ${cls}`}`, css)} d="${polygonPath(c.cells[i])}"${markAttrs(env, p.d.id, p.index, [p.x, p.y])}`, `${[who(p), teamKey(p.d.team) === "" ? "" : teamLabel(teamKey(p.d.team), env)].filter((t) => t !== "").join(", ")}: ${round(100 * c.shares[i])}%`));
     });
     if (layer.points !== false)
-        out.push(dots(c.players, env.base * 0.55, () => undefined));
+        out.push(dots(c.players, env.base * 0.55, () => undefined, env));
     made.marks = out.join("");
     made.title = fill(words.voronoiTitle, { n: c.players.length });
     const list = [...c.teams].sort((a, b) => b.share - a.share).map((t) => fill(words.shareItem, { name: teamLabel(t.team, env), pct: round(100 * t.share) })).join(env.words.layers.listSep);
@@ -140,7 +140,7 @@ export function drawDelaunay(layer, env) {
             out.push(titled("path", `${attrs(`ky-sp ky-sp-e${cls === "" ? "" : ` ${cls}`}`, "")} d="${g.edges.map(([a, b]) => `M${num(a[0])} ${num(a[1])}L${num(b[0])} ${num(b[1])}`).join("")}"`, tip));
     }
     if (layer.points !== false)
-        out.push(dots(c.all, env.base * 0.55, () => undefined));
+        out.push(dots(c.all, env.base * 0.55, () => undefined, env));
     made.marks = out.join("");
     made.title = fill(words.delaunayTitle, { n: c.all.length });
     const triangles = c.groups.reduce((s, g) => s + g.triangles.length, 0);
@@ -193,7 +193,7 @@ export function drawHull(layer, env) {
             out.push(titled("path", `${attrs(`ky-sp ky-sp-e${cls === "" ? "" : ` ${cls}`}`, "")} d="M${num(h.corners[0][0])} ${num(h.corners[0][1])}L${num(h.corners[1][0])} ${num(h.corners[1][1])}"`, tip));
     }
     if (layer.points !== false)
-        out.push(dots(c.all, env.base * 0.55, () => undefined));
+        out.push(dots(c.all, env.base * 0.55, () => undefined, env));
     made.marks = out.join("");
     made.title = fill(words.hullTitle, { n: c.all.length });
     const parts = [c.hulls.map((h) => fill(words.hullItem, { name: teamLabel(h.team, env), n: h.players.length, area: Math.round(h.area), unit: squareWord(c.unit, env) })).join(env.words.layers.listSep) + env.words.said.stop];

package/dist/team.types.d.ts

@@ -140,9 +140,11 @@ export interface FormationPosition {
     id: string;
     x: number;
     y: number;
+    /** How big the mark of a lineup is here, against the others: 1 by default. A second line's marks are smaller. */
+    size?: number;
 }
 /** The sports that have formations. */
-export type FormationSport = "soccer" | "nhl" | "nba" | "nfl" | "mlb";
+export type FormationSport = "soccer" | "nhl" | "nba" | "nfl" | "mlb" | "rugby" | "afl" | "cricket" | "volleyball" | "handball" | "waterpolo" | "fieldhockey" | "netball";
 /** A formation: where each position stands. Points in the numbers of a registered frame, for a team that attacks the right end of the surface as it is drawn wide (a football formation: the offence going right, with the ball at midfield). */
 export interface Formation {
     id: string;
@@ -159,6 +161,8 @@ export interface Formation {
         ja: string;
     };
     positions: readonly FormationPosition[];
+    /** Places beside the surface's play that a lineup lists but the side does not field: baseball's designated hitter. A `formation` layer leaves them out; a `lineup` draws them. */
+    extra?: readonly FormationPosition[];
 }
 /** A player to stand on a position. */
 export interface FormationPlayer extends MarkDatum {
@@ -186,4 +190,39 @@ export interface FormationLayer extends LayerBase {
     los?: number;
     opacity?: number;
 }
+/** A player of a lineup, placed by a position's code: nothing else about where he stands is needed. */
+export interface LineupPlayer extends MarkDatum {
+    /** The position's code: `GK`, `SS`, `C`, `QB`, `9`, `P4` (a volleyball court's zone). The formation's own ids, and the usual short ones (`CB` for a centre-back of either side, `D` for a defenceman, `OF` for an outfielder), as `LINEUP_CODES` lists. */
+    pos: string | number;
+    name?: string;
+    number?: string | number;
+    /** A flag or crest for a small badge on the mark: an SVG as text, an image `data:` address or a path or address of an image. The package draws no flag of its own. */
+    flag?: string;
+    /** The captain wears an armband: a small "C" on the mark. */
+    captain?: boolean;
+    /** 1 by default. Hockey's second line is `line: 2` with the same codes. */
+    line?: number;
+}
+/** A team's lineup drawn on the surface: its players placed by position code in a named formation, as discs or jerseys, each with its number in the mark and its name under it. Two teams are two layers, one for each `side`. A lineup is not cut to the surface's outline (a fielder at the foul line keeps his whole jersey) unless `clip` is `"surface"`. */
+export interface LineupLayer extends LayerBase {
+    kind: "lineup";
+    /** `home` (the default) or `away`: the team's colour, and the end it attacks (the right for `home`, the left for `away`) unless `attacking` says. A football lineup's `side` is only the colour: the offence goes right unless `attacking` says, and a defence faces it. Baseball's fielders do not turn. */
+    side?: "home" | "away";
+    /** The id of a formation in `FORMATIONS` (`4-2-3-1`), or a formation of your own. Without it, the one of the surface's sport that places the most of the players, the first of its sport's table on a tie. */
+    formation?: string | Formation;
+    players: readonly LineupPlayer[];
+    /** `disc` (the default) or `jersey`. */
+    shape?: "disc" | "jersey";
+    /** What is written in a mark: the shirt `number` (the default), the `position`'s code, the `name` or `none`. */
+    labels?: "number" | "position" | "name" | "none";
+    /** Write each name under its mark. On by default. */
+    names?: boolean;
+    /** The width of a mark, in the layer's units. A share of the surface's longer side by default. */
+    size?: number;
+    /** A volleyball lineup is listed in the serving order, `P1` to `P6`; `rotation` (1 to 6) is how many rotations on: each player moves one place clockwise. 1 by default. */
+    rotation?: number;
+    /** The line of scrimmage of a football lineup, as for a `formation` layer. */
+    los?: number;
+    opacity?: number;
+}
 export {};

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[]>>;