@johnmorrisdotca/kyogijo-stadiums 0.0.0-stage → 0.4.0

package/dist/atlas.js

@@ -0,0 +1,149 @@
+import { GROUNDS, GROUND_IDS } from "./grounds.js";
+import { nameContainsAll, placesNamed, plainName } from "./names.js";
+import { PARKS, PARK_IDS } from "./parks.js";
+const leaguesOfGround = (ground) => {
+    const leagues = [];
+    if (ground.tournaments.some((t) => t.competition === "world-cup"))
+        leagues.push("FIFA World Cup");
+    if (ground.tournaments.some((t) => t.competition === "womens-world-cup"))
+        leagues.push("FIFA Women's World Cup");
+    return leagues;
+};
+const fromPark = (park) => {
+    const from = park.from ?? park.opened;
+    const to = park.to ?? park.closed;
+    return {
+        id: park.id,
+        kind: "park",
+        name: park.name,
+        nameJa: park.nameJa,
+        ...(park.readingJa === undefined ? {} : { readingJa: park.readingJa }),
+        ...(park.localName === undefined ? {} : { localName: park.localName, localLanguage: park.localLanguage }),
+        aliases: park.aliases ?? [],
+        sport: "baseball",
+        leagues: [park.league],
+        country: park.country,
+        city: park.city,
+        team: park.team,
+        lat: park.lat,
+        lon: park.lon,
+        // A ground a club also uses (`secondary`) is in use today.
+        status: park.status === "past" ? "past" : "current",
+        ...(from === undefined ? {} : { from }),
+        ...(park.status === "past" && to !== undefined ? { to } : {}),
+        wikidata: park.wikidata,
+    };
+};
+const fromGround = (ground) => ({
+    id: ground.id,
+    kind: "ground",
+    name: ground.name,
+    nameJa: ground.nameJa,
+    ...(ground.readingJa === undefined ? {} : { readingJa: ground.readingJa }),
+    ...(ground.localName === undefined ? {} : { localName: ground.localName, localLanguage: ground.localLanguage }),
+    aliases: ground.aliases ?? [],
+    ...(ground.names === undefined ? {} : { names: ground.names }),
+    sport: "soccer",
+    leagues: leaguesOfGround(ground),
+    country: ground.country,
+    city: ground.city,
+    lat: ground.lat,
+    lon: ground.lon,
+    status: ground.status,
+    ...(ground.from === undefined ? {} : { from: ground.from }),
+    ...(ground.status === "past" && ground.to !== undefined ? { to: ground.to } : {}),
+    wikidata: ground.wikidata,
+});
+/**
+ * Every place the package draws, parks first and then grounds, each in the order of its own list: the ballparks of
+ * `PARKS` and the soccer grounds of `GROUNDS`, with where each stands.
+ * @example
+ * ```ts
+ * import { PLACES } from "@johnmorrisdotca/kyogijo-stadiums/atlas";
+ * const fenway = PLACES.find((place) => place.id === "fenway-park");
+ * console.log(fenway?.name, fenway?.lat, fenway?.lon, fenway?.country);
+ * // Fenway Park 42.34639 -71.0975 US
+ * ```
+ */
+export const PLACES = Object.freeze([...PARK_IDS.map((id) => fromPark(PARKS[id])), ...GROUND_IDS.map((id) => fromGround(GROUNDS[id]))]);
+const BY_ID = new Map(PLACES.map((place) => [place.id, place]));
+/** The place with a key, or `undefined`. */
+export const placeById = (id) => (id === undefined ? undefined : BY_ID.get(id));
+/**
+ * The places that answer to a name, best match first: the everyday names, then the official and cited names and the sponsors', then the former names and the nicknames. The comparison
+ * ignores case, accents, spaces and punctuation, width, and in Japanese hiragana or katakana and the long vowel mark.
+ * @example
+ * ```ts
+ * import { placeByName, placesByName } from "@johnmorrisdotca/kyogijo-stadiums/atlas";
+ * console.log(placeByName("Koshien Stadium")?.id, placeByName("サン・シーロ")?.id, placeByName("Estadio Jornalista Mario Filho")?.id, placesByName("wrigley field").map((place) => place.id).join());
+ * // hanshin-koshien-stadium san-siro maracana wrigley-field,wrigley-field-los-angeles
+ * ```
+ */
+export const placesByName = (name) => placesNamed(PLACES, name);
+/** The place a name belongs to (see `placesByName`; the best match when several answer to it), or `undefined`. */
+export const placeByName = (name) => placesByName(name)[0];
+const plain = plainName;
+const many = (value) => (value === undefined ? undefined : Array.isArray(value) ? value : [value]);
+/**
+ * The places that match every field of the filter, in the order of `PLACES`.
+ * @example
+ * ```ts
+ * import { placesBy } from "@johnmorrisdotca/kyogijo-stadiums/atlas";
+ * const japan = placesBy({ sport: "baseball", country: "JP", status: "current" });
+ * const in1950 = placesBy({ year: 1950, country: "US" });
+ * console.log(japan.length, in1950.some((place) => place.id === "ebbets-field"));
+ * // 14 true
+ * ```
+ */
+export function placesBy(filter = {}) {
+    const sports = many(filter.sport);
+    const kinds = many(filter.kind);
+    const leagues = many(filter.league);
+    const countries = many(filter.country);
+    const statuses = many(filter.status);
+    const year = filter.year !== undefined && Number.isFinite(filter.year) ? filter.year : undefined;
+    const words = filter.text === undefined ? [] : filter.text.split(/\s+/).map(plain).filter(Boolean);
+    return PLACES.filter((place) => {
+        if (sports !== undefined && !sports.includes(place.sport))
+            return false;
+        if (kinds !== undefined && !kinds.includes(place.kind))
+            return false;
+        if (leagues !== undefined && !place.leagues.some((league) => leagues.includes(league)))
+            return false;
+        if (countries !== undefined && !countries.includes(place.country))
+            return false;
+        if (statuses !== undefined && !statuses.includes(place.status))
+            return false;
+        if (year !== undefined && ((place.from !== undefined && year < place.from) || (place.to !== undefined && year > place.to)))
+            return false;
+        if (words.length > 0) {
+            const haystack = plain([place.city, place.team, place.country].filter(Boolean).join(" "));
+            if (!words.every((word) => haystack.includes(word) || nameContainsAll(place, [word])))
+                return false;
+        }
+        return true;
+    });
+}
+/**
+ * The sports, leagues and countries of the places, and the span of years they give.
+ * @example
+ * ```ts
+ * import { atlasFacets } from "@johnmorrisdotca/kyogijo-stadiums/atlas";
+ * const { sports, leagues, countries, years } = atlasFacets();
+ * console.log(sports.join(), leagues.join(), countries.length, years.min);
+ * // baseball,soccer FIFA Women's World Cup,FIFA World Cup,MLB,NPB 23 1877
+ * ```
+ */
+export function atlasFacets() {
+    const years = PLACES.flatMap((place) => [place.from, place.to]).filter((year) => year !== undefined);
+    return {
+        sports: [...new Set(PLACES.map((place) => place.sport))].sort(),
+        leagues: [...new Set(PLACES.flatMap((place) => place.leagues))].sort(),
+        countries: [...new Set(PLACES.map((place) => place.country))].sort(),
+        years: { min: Math.min(...years), max: Math.max(...years) },
+    };
+}
+/** The options `drawKyogijo` takes to draw a place's surface: a park's fence or a ground's pitch at its own size. */
+export function surfaceOf(place) {
+    return place.kind === "park" ? { sport: "mlb", park: place.id } : { sport: "soccer", ground: place.id };
+}

package/dist/background.d.ts

@@ -0,0 +1,56 @@
+/** The patterns: a tile of shapes repeated over the ground. */
+export type BackgroundPattern = "felt" | "grass" | "wood" | "ice" | "paper" | "grid" | "dots";
+/** How a photograph fills the ground: `cover` fills it and cuts what overhangs, `contain` shows all of it, `stretch` fills it out of shape. */
+export type BackgroundFit = "cover" | "contain" | "stretch";
+/** A ground in full. Every part is optional; with none, there is no ground. */
+export interface BackgroundOptions {
+    /** A pattern drawn over the ground, in a low opacity. */
+    pattern?: BackgroundPattern;
+    /** A colour under the pattern and the photograph (a hex colour, `rgb()`, `hsl()`, a name or `var(--name)`). Without it the ground keeps its own colour. */
+    color?: string;
+    /** The opacity of the pattern, 0 to 1. Each pattern has its own subtle one. */
+    opacity?: number;
+    /** The size of the pattern's tile, as a multiple of its usual one (a fortyeighth of the drawing's longer side). 1 by default; 0.25 to 8 are kept. */
+    scale?: number;
+    /** A photograph behind the surface: an address or `data:` image, held to the rules of a team's `logo` (`safeLogo`). Drawn over the ground's colour and under the pattern. */
+    image?: string;
+    /** The opacity of the photograph, 0 to 1. 0.35 by default. */
+    imageOpacity?: number;
+    /** How the photograph fills the ground. `cover` by default. */
+    imageFit?: BackgroundFit;
+}
+/** A ground: a pattern's name, `"none"`, or the options in full. */
+export type Background = BackgroundPattern | "none" | BackgroundOptions;
+/** The patterns, in the order a menu lists them. */
+export declare const BACKGROUND_PATTERNS: readonly BackgroundPattern[];
+/** The opacity each pattern is drawn at when `opacity` says nothing. */
+export declare const BACKGROUND_OPACITY: Readonly<Record<BackgroundPattern, number>>;
+/** The rules of a ground, written into a drawing that has one (and in `KYOGIJO_STYLE`, for a page that supplies the stylesheet): the pattern's ink and light. */
+export declare const KYOGIJO_BACKGROUND_STYLE: string;
+/** The options of a ground, read: a name becomes a pattern, `"none"`, anything that is not a ground and a ground with nothing in it are `undefined`. */
+export declare function resolveBackground(value: unknown): BackgroundOptions | undefined;
+/** What a ground is made of: the pieces to write in the drawing's `<defs>` and the shapes to lay over the apron. */
+export interface BackgroundMarkup {
+    defs: string;
+    shapes: string;
+}
+/**
+ * The ground as SVG: a rectangle `box` in the drawing's own numbers, filled with the colour, the photograph and the pattern, in that order, and the definitions they need
+ * (a pattern and, for a photograph that overhangs, a clip), with ids that begin with `id`. The tile is a fortyeighth of the box's longer side, times `scale`, so that a ground
+ * looks the same on a rink in feet and on a card in pixels. An empty string for each when there is no ground.
+ */
+export declare function backgroundMarkup(background: Background | undefined, box: {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}, id: string): BackgroundMarkup;
+/**
+ * A drawing's `base` with a ground laid on its apron: the base's first shape is the apron's rectangle, and the ground is written right after it, over exactly the same
+ * rectangle, so that it lies under the surface and over the apron's colour. `defs` is what the ground needs in the drawing's `<defs>`. A base that does not begin with a
+ * rectangle, or a ground with nothing in it, leaves the base as it is.
+ */
+export declare function laidOn(base: string, background: Background | undefined, id: string): {
+    base: string;
+    defs: string;
+};

package/dist/background.js

@@ -0,0 +1,127 @@
+// The ground behind a drawing: a subtle pattern drawn in SVG (felt, grass, wood, ice, paper, a grid, dots) and, when the caller has one, a photograph at an opacity. It is
+// written once here for the drawing (`background` in the options, laid on the apron under the surface) and for a grid of drawings (`drawGrid`, laid under all of them).
+// Every pattern is a few shapes in a tile, with no random number, in the ink or the line colour of the drawing at a low opacity, so that it follows light and dark.
+import { safeColour, safeLogo } from "./colour.js";
+import { el, num } from "./format.js";
+/** The patterns, in the order a menu lists them. */
+export const BACKGROUND_PATTERNS = ["felt", "grass", "wood", "ice", "paper", "grid", "dots"];
+/** The opacity each pattern is drawn at when `opacity` says nothing. */
+export const BACKGROUND_OPACITY = { felt: 0.8, grass: 0.7, wood: 0.8, ice: 0.9, paper: 0.75, grid: 0.55, dots: 0.7 };
+/** The rules of a ground, written into a drawing that has one (and in `KYOGIJO_STYLE`, for a page that supplies the stylesheet): the pattern's ink and light. */
+export const KYOGIJO_BACKGROUND_STYLE = `
+.kyogijo .ky-bg-i{stroke:var(--ky-ink);fill:none}
+.kyogijo .ky-bg-id{fill:var(--ky-ink);stroke:none}
+.kyogijo .ky-bg-l{stroke:var(--ky-line);fill:none}
+.kyogijo .ky-bg-ld{fill:var(--ky-line);stroke:none}`.trim();
+const has = (name) => typeof name === "string" && BACKGROUND_PATTERNS.includes(name);
+const unit = (value, fallback) => (typeof value === "number" && Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : fallback);
+/** The options of a ground, read: a name becomes a pattern, `"none"`, anything that is not a ground and a ground with nothing in it are `undefined`. */
+export function resolveBackground(value) {
+    if (value === undefined || value === null || value === "none")
+        return undefined;
+    if (typeof value === "string")
+        return has(value) ? { pattern: value } : undefined;
+    if (typeof value !== "object")
+        return undefined;
+    const o = value;
+    const out = {};
+    if (has(o.pattern))
+        out.pattern = o.pattern;
+    const color = safeColour(o.color);
+    if (color !== undefined)
+        out.color = color;
+    if (typeof o.opacity === "number" && Number.isFinite(o.opacity))
+        out.opacity = unit(o.opacity, BACKGROUND_OPACITY[out.pattern ?? "felt"]);
+    if (typeof o.scale === "number" && Number.isFinite(o.scale))
+        out.scale = Math.min(8, Math.max(0.25, o.scale));
+    const image = safeLogo(o.image);
+    if (image !== undefined)
+        out.image = image;
+    if (typeof o.imageOpacity === "number" && Number.isFinite(o.imageOpacity))
+        out.imageOpacity = unit(o.imageOpacity, 0.35);
+    if (o.imageFit === "cover" || o.imageFit === "contain" || o.imageFit === "stretch")
+        out.imageFit = o.imageFit;
+    return out.pattern === undefined && out.color === undefined && out.image === undefined ? undefined : out;
+}
+/** The tile of a pattern: its width and height and the shapes in it, for a tile of side `t`. */
+function tile(pattern, t) {
+    const n = (v) => num(Math.round(v * 1000) / 1000);
+    const line = (cls, x1, y1, x2, y2, width) => el("line", { class: cls, x1: n(x1), y1: n(y1), x2: n(x2), y2: n(y2), "stroke-width": n(width), "stroke-linecap": "round" });
+    const dot = (cls, x, y, r) => el("circle", { class: cls, cx: n(x), cy: n(y), r: n(r) });
+    switch (pattern) {
+        case "felt":
+            return {
+                w: t,
+                h: t,
+                body: [dot("ky-bg-ld", 0.12 * t, 0.2 * t, 0.045 * t), dot("ky-bg-id", 0.58 * t, 0.12 * t, 0.04 * t), dot("ky-bg-ld", 0.82 * t, 0.46 * t, 0.05 * t), dot("ky-bg-id", 0.3 * t, 0.55 * t, 0.045 * t), dot("ky-bg-ld", 0.66 * t, 0.84 * t, 0.04 * t), dot("ky-bg-id", 0.08 * t, 0.9 * t, 0.05 * t), dot("ky-bg-ld", 0.45 * t, 0.36 * t, 0.03 * t)].join(""),
+            };
+        case "grass":
+            return {
+                w: t,
+                h: t,
+                body: [line("ky-bg-l", 0.1 * t, 0.46 * t, 0.2 * t, 0.2 * t, 0.05 * t), line("ky-bg-l", 0.4 * t, 0.9 * t, 0.46 * t, 0.58 * t, 0.05 * t), line("ky-bg-l", 0.64 * t, 0.4 * t, 0.58 * t, 0.12 * t, 0.05 * t), line("ky-bg-l", 0.86 * t, 0.96 * t, 0.94 * t, 0.7 * t, 0.05 * t), line("ky-bg-i", 0.26 * t, 0.98 * t, 0.2 * t, 0.78 * t, 0.04 * t), line("ky-bg-i", 0.78 * t, 0.5 * t, 0.84 * t, 0.28 * t, 0.04 * t)].join(""),
+            };
+        case "wood": {
+            const w = 2 * t;
+            const grain = (y, bend) => el("path", { class: "ky-bg-i", d: `M0 ${n(y)}Q${n(0.5 * t)} ${n(y - bend)} ${n(t)} ${n(y)}T${n(w)} ${n(y)}`, "stroke-width": n(0.025 * t) });
+            return { w, h: t, body: [grain(0.22 * t, 0.12 * t), grain(0.48 * t, -0.1 * t), grain(0.72 * t, 0.08 * t), line("ky-bg-i", 0, t, w, t, 0.05 * t), line("ky-bg-i", 0.7 * t, 0, 0.7 * t, 0.5 * t, 0.04 * t), line("ky-bg-i", 1.4 * t, 0.5 * t, 1.4 * t, t, 0.04 * t)].join("") };
+        }
+        case "ice":
+            return { w: 2 * t, h: 2 * t, body: [line("ky-bg-l", 0.2 * t, 0.4 * t, 0.9 * t, 0.15 * t, 0.022 * t), line("ky-bg-l", 1.1 * t, 1.5 * t, 1.9 * t, 1.1 * t, 0.022 * t), line("ky-bg-l", 0.3 * t, 1.7 * t, 0.7 * t, 1.9 * t, 0.022 * t), line("ky-bg-l", 1.3 * t, 0.3 * t, 1.6 * t, 0.7 * t, 0.022 * t), line("ky-bg-i", 0.9 * t, 1.0 * t, 1.2 * t, 0.9 * t, 0.014 * t)].join("") };
+        case "paper":
+            return { w: 2 * t, h: 2 * t, body: [line("ky-bg-i", 0.3 * t, 0.3 * t, 0.42 * t, 0.34 * t, 0.022 * t), line("ky-bg-i", 1.2 * t, 0.2 * t, 1.1 * t, 0.3 * t, 0.022 * t), line("ky-bg-i", 0.8 * t, 0.9 * t, 0.95 * t, 0.88 * t, 0.022 * t), line("ky-bg-i", 1.6 * t, 1.1 * t, 1.72 * t, 1.18 * t, 0.022 * t), line("ky-bg-i", 0.2 * t, 1.5 * t, 0.3 * t, 1.42 * t, 0.022 * t), line("ky-bg-i", 1.0 * t, 1.7 * t, 1.14 * t, 1.76 * t, 0.022 * t), dot("ky-bg-id", 0.6 * t, 0.6 * t, 0.022 * t), dot("ky-bg-id", 1.5 * t, 1.6 * t, 0.022 * t)].join("") };
+        case "grid":
+            return { w: t, h: t, body: el("path", { class: "ky-bg-i", d: `M0 0H${n(t)}M0 0V${n(t)}`, "stroke-width": n(0.035 * t) }) };
+        default:
+            return { w: t, h: t, body: dot("ky-bg-id", t / 2, t / 2, 0.05 * t) };
+    }
+}
+/**
+ * The ground as SVG: a rectangle `box` in the drawing's own numbers, filled with the colour, the photograph and the pattern, in that order, and the definitions they need
+ * (a pattern and, for a photograph that overhangs, a clip), with ids that begin with `id`. The tile is a fortyeighth of the box's longer side, times `scale`, so that a ground
+ * looks the same on a rink in feet and on a card in pixels. An empty string for each when there is no ground.
+ */
+export function backgroundMarkup(background, box, id) {
+    const b = resolveBackground(background);
+    if (b === undefined)
+        return { defs: "", shapes: "" };
+    const at = { x: num(box.x), y: num(box.y), width: num(box.w), height: num(box.h) };
+    let defs = "";
+    let shapes = "";
+    if (b.color !== undefined)
+        shapes += el("rect", { class: "ky-bg", ...at, fill: b.color });
+    if (b.image !== undefined) {
+        const fit = b.imageFit ?? "cover";
+        const clip = `${id}-bgc`;
+        // A photograph that fills the ground may overhang it, and a canvas has no `slice`: the clip cuts it, as the SVG's own rule would.
+        if (fit === "cover")
+            defs += el("clipPath", { id: clip }, el("rect", at));
+        const picture = el("image", { class: "ky-bg-img", href: b.image, x: at.x, y: at.y, width: at.width, height: at.height, preserveAspectRatio: fit === "cover" ? "xMidYMid slice" : fit === "contain" ? "xMidYMid meet" : "none", opacity: b.imageOpacity ?? 0.35 });
+        shapes += fit === "cover" ? el("g", { "clip-path": `url(#${clip})` }, picture) : picture;
+    }
+    if (b.pattern !== undefined) {
+        const side = (Math.max(box.w, box.h) / 48) * (b.scale ?? 1);
+        const { w, h, body } = tile(b.pattern, side);
+        const key = `${id}-bg`;
+        defs += el("pattern", { id: key, width: num(w), height: num(h), patternUnits: "userSpaceOnUse" }, el("g", { opacity: b.opacity ?? BACKGROUND_OPACITY[b.pattern] }, body));
+        shapes += el("rect", { class: "ky-bg-pattern", ...at, fill: `url(#${key})` });
+    }
+    return { defs, shapes };
+}
+/**
+ * A drawing's `base` with a ground laid on its apron: the base's first shape is the apron's rectangle, and the ground is written right after it, over exactly the same
+ * rectangle, so that it lies under the surface and over the apron's colour. `defs` is what the ground needs in the drawing's `<defs>`. A base that does not begin with a
+ * rectangle, or a ground with nothing in it, leaves the base as it is.
+ */
+export function laidOn(base, background, id) {
+    if (resolveBackground(background) === undefined || !base.startsWith("<rect "))
+        return { base, defs: "" };
+    const end = base.indexOf("/>") + 2;
+    const tag = base.slice(0, end);
+    const read = (name) => Number(new RegExp(`\\s${name}="(-?[\\d.]+)"`).exec(tag)?.[1] ?? "NaN");
+    const box = { x: read("x"), y: read("y"), w: read("width"), h: read("height") };
+    if (![box.x, box.y, box.w, box.h].every(Number.isFinite))
+        return { base, defs: "" };
+    const made = backgroundMarkup(background, box, id);
+    return { base: `${tag}${made.shapes}${base.slice(end)}`, defs: made.defs };
+}

package/dist/ballpark.d.ts

@@ -0,0 +1,48 @@
+import { type ParkDugouts, type ParkQuirk, type ParkWall } from "./parks.ts";
+import { type KyogijoWords } from "./strings.ts";
+import type { Language, SurfaceOptions } from "./types.ts";
+/** The unit the heights and distances are written in: feet, or metres for a drawing in metres, centimetres or millimetres. */
+export type BallparkUnit = "ft" | "m";
+/** What a ballpark drawing has been asked to add to the plain field. */
+export interface Ballpark {
+    /** The warning track's width in feet where the park's article gives it. */
+    track?: number;
+    /** The stretches of wall to draw, with their heights in feet; none unless `walls` is asked for. */
+    walls: readonly ParkWall[];
+    legend: boolean;
+    wallLabels: boolean;
+    /** The quirks to draw. */
+    quirks: readonly ParkQuirk[];
+    /** The distance to the backstop in feet, when `quirks` asks for it and the article gives it. */
+    backstop?: number;
+    dugouts?: ParkDugouts;
+    quirkLabels: boolean;
+    unit: BallparkUnit;
+    language: Language;
+    words: KyogijoWords["ballpark"];
+}
+/** True when a drawing has something of a ballpark to add (its stylesheet is then written in). */
+export declare const ballparkDrawn: (b: Ballpark | undefined) => boolean;
+/**
+ * The ballpark of a drawing: the park the options name, in the season they name, with the walls and quirks they ask for. `undefined` for a drawing with no park.
+ * A request that cannot be read is left out, as the other options' are.
+ */
+export declare function ballparkFor(o: SurfaceOptions): Ballpark | undefined;
+/** A length in feet as it is written: in feet, or in metres, to a tenth. */
+export declare function lengthText(feet: number, unit: BallparkUnit): string;
+/** Where a stretch of fence stands, in words: the whole outfield, or the part of the field its middle falls in. */
+export declare function sectionName(from: number, to: number, words: KyogijoWords["ballpark"]): string;
+/** The name of a wall: the article's, else where the article puts it, else where its middle falls in the field. */
+export declare const wallName: (wall: ParkWall, words: KyogijoWords["ballpark"]) => string;
+/** The wall as one phrase: its name and its height. */
+export declare function wallText(wall: ParkWall, b: Pick<Ballpark, "unit" | "words">): string;
+/** What the tiers of the legend say, from the thresholds of 10, 20 and 30 feet: `under 10 ft`, `10 to 20 ft`, `20 to 30 ft`, `30 ft and over`. */
+export declare function tierTexts(b: Pick<Ballpark, "unit" | "words">): string[];
+/** The tier a height falls in, 1 to 4. */
+export declare const tierOf: (feet: number) => 1 | 2 | 3 | 4;
+/** What a quirk is called: the article's name for it, else its kind's. */
+export declare function quirkName(q: ParkQuirk, words: KyogijoWords["ballpark"]): string;
+/** A quirk in a phrase, with its figures. */
+export declare function quirkText(q: ParkQuirk, b: Pick<Ballpark, "unit" | "words">): string;
+/** The sentences a ballpark adds to a drawing's description: its walls, then its quirks. */
+export declare function ballparkSentences(b: Ballpark): string[];

package/dist/ballpark.js

@@ -0,0 +1,129 @@
+// What a ballpark's article gives beyond the fence's distances, turned into what a drawing is asked for: the walls and their heights (`walls`), the quirks
+// (`quirks`), the warning track's width, and the words that name them. The figures are in parks.ts; this file reads the options and says what to draw and what to say.
+import { lengthUnit } from "./common.js";
+import { parkById, parkQuirksIn, parkWallsIn } from "./parks.js";
+import { KYOGIJO_STRINGS, fill } from "./strings.js";
+/** True when a drawing has something of a ballpark to add (its stylesheet is then written in). */
+export const ballparkDrawn = (b) => b !== undefined && (b.walls.length > 0 || b.quirks.length > 0 || b.backstop !== undefined || b.dugouts !== undefined);
+const QUIRK_NAMES = ["hill", "overhang", "pole", "flagpole", "bullpen", "ivy", "basket", "backstop", "dugouts"];
+/**
+ * The ballpark of a drawing: the park the options name, in the season they name, with the walls and quirks they ask for. `undefined` for a drawing with no park.
+ * A request that cannot be read is left out, as the other options' are.
+ */
+export function ballparkFor(o) {
+    const park = parkById(o.park);
+    if (park === undefined)
+        return undefined;
+    const language = o.language === "ja" ? "ja" : "en";
+    const unit = ["m", "cm", "mm"].includes(lengthUnit(o)) ? "m" : "ft";
+    const asked = o.walls === true || (typeof o.walls === "object" && o.walls !== null);
+    const wall = typeof o.walls === "object" && o.walls !== null ? o.walls : {};
+    const quirked = o.quirks === true || (typeof o.quirks === "object" && o.quirks !== null);
+    const quirk = typeof o.quirks === "object" && o.quirks !== null ? o.quirks : {};
+    const only = Array.isArray(quirk.only) ? new Set(quirk.only.filter((name) => QUIRK_NAMES.includes(name))) : undefined;
+    const wants = (name) => quirked && (only === undefined || only.has(name));
+    const walls = asked ? parkWallsIn(park, o.year) : [];
+    return {
+        track: park.track_ft,
+        walls,
+        legend: walls.length > 0 && wall.legend === true,
+        wallLabels: wall.labels === true,
+        quirks: parkQuirksIn(park, o.year).filter((q) => wants(q.kind)),
+        backstop: wants("backstop") ? park.backstop_ft : undefined,
+        dugouts: wants("dugouts") ? park.dugouts : undefined,
+        quirkLabels: quirk.labels === true,
+        unit,
+        language,
+        words: KYOGIJO_STRINGS[language].ballpark,
+    };
+}
+/** A length in feet as it is written: in feet, or in metres, to a tenth. */
+export function lengthText(feet, unit) {
+    const value = unit === "m" ? feet * 0.3048 : feet;
+    return String(Math.round(value * 10) / 10);
+}
+/** Where a stretch of fence stands, in words: the whole outfield, or the part of the field its middle falls in. */
+export function sectionName(from, to, words) {
+    if (to - from >= 80)
+        return words.sections.outfield;
+    const mid = (from + to) / 2;
+    const { left, leftCenter, center, rightCenter, right } = words.sections;
+    return mid < -27 ? left : mid < -9 ? leftCenter : mid <= 9 ? center : mid <= 27 ? rightCenter : right;
+}
+/** The name of a wall: the article's, else where the article puts it, else where its middle falls in the field. */
+export const wallName = (wall, words) => wall.label ?? (wall.place === undefined ? sectionName(wall.from, wall.to, words) : words.sections[wall.place]);
+/** The wall as one phrase: its name and its height. */
+export function wallText(wall, b) {
+    return fill(b.words.height, { name: wallName(wall, b.words), height: lengthText(wall.height_ft, b.unit), unit: b.words.unit[b.unit] });
+}
+/** What the tiers of the legend say, from the thresholds of 10, 20 and 30 feet: `under 10 ft`, `10 to 20 ft`, `20 to 30 ft`, `30 ft and over`. */
+export function tierTexts(b) {
+    const unit = b.words.unit[b.unit];
+    const at = (feet) => lengthText(feet, b.unit);
+    const { under, between, over } = b.words.tiers;
+    return [fill(under, { a: at(10), unit }), fill(between, { a: at(10), b: at(20), unit }), fill(between, { a: at(20), b: at(30), unit }), fill(over, { a: at(30), unit })];
+}
+/** The tier a height falls in, 1 to 4. */
+export const tierOf = (feet) => (feet < 10 ? 1 : feet < 20 ? 2 : feet < 30 ? 3 : 4);
+/** What a quirk is called: the article's name for it, else its kind's. */
+export function quirkName(q, words) {
+    if (q.label !== undefined)
+        return q.label;
+    const k = words.kinds;
+    switch (q.kind) {
+        case "hill":
+            return k.hillName;
+        case "overhang":
+            return k.overhangName;
+        case "pole":
+            return k.poleName;
+        case "flagpole":
+            return k.flagpoleName;
+        case "bullpen":
+            return q.side === "home" ? k.bullpenHome : q.side === "visitors" ? k.bullpenVisitors : k.bullpen;
+        case "ivy":
+            return k.ivy;
+        case "basket":
+            return k.basket;
+    }
+}
+/** A quirk in a phrase, with its figures. */
+export function quirkText(q, b) {
+    const k = b.words.kinds;
+    const unit = b.words.unit[b.unit];
+    const name = quirkName(q, b.words);
+    const at = (feet) => lengthText(feet, b.unit);
+    switch (q.kind) {
+        case "hill":
+            return fill(q.slope_deg === undefined ? k.hill : k.hillSlope, { name, width: at(q.width_ft), unit, slope: q.slope_deg ?? 0 });
+        case "overhang":
+            return fill(k.overhang, { name, depth: at(q.depth_ft), unit });
+        case "pole":
+        case "flagpole":
+            return fill(k.pole, { name, feet: at(q.feet), unit });
+        case "bullpen":
+            return fill(k.bullpenItem, { name, feet: at(q.feet), unit });
+        case "ivy":
+        case "basket":
+            return name;
+    }
+}
+/** The sentences a ballpark adds to a drawing's description: its walls, then its quirks. */
+export function ballparkSentences(b) {
+    const out = [];
+    const sep = KYOGIJO_STRINGS[b.language].layers.listSep;
+    if (b.walls.length > 0)
+        out.push(fill(b.words.walls, { list: b.walls.map((wall) => wallText(wall, b)).join(sep) }));
+    const items = b.quirks.map((q) => quirkText(q, b));
+    const k = b.words.kinds;
+    const unit = b.words.unit[b.unit];
+    if (b.backstop !== undefined)
+        items.push(fill(k.backstop, { feet: lengthText(b.backstop, b.unit), unit }));
+    if (b.dugouts?.home !== undefined)
+        items.push(fill(k.dugoutHome, { line: k[b.dugouts.home] }));
+    if (b.dugouts?.visitors !== undefined)
+        items.push(fill(k.dugoutVisitors, { line: k[b.dugouts.visitors] }));
+    if (items.length > 0)
+        out.push(fill(b.words.quirks, { list: items.join(sep) }));
+    return out;
+}

package/dist/canvas-entry.d.ts

@@ -0,0 +1,2 @@
+export { drawToCanvas, withAlpha } from "./canvas.ts";
+export type { CanvasContext, CanvasGradientLike, CanvasOptions, Drawn } from "./canvas.ts";

package/dist/canvas-entry.js

@@ -0,0 +1,2 @@
+// A drawing on a canvas context (a browser's, an OffscreenCanvas's or a Node canvas's), with no canvas library imported.
+export { drawToCanvas, withAlpha } from "./canvas.js";

package/dist/canvas.d.ts

@@ -0,0 +1,85 @@
+import type { SceneOptions, SceneSource } from "./scene.types.ts";
+/** A gradient the context makes: only `addColorStop` is called on it. */
+export interface CanvasGradientLike {
+    addColorStop(offset: number, color: string): void;
+}
+/**
+ * The members of a 2D canvas context that are used, with the types of the standard ones. A `CanvasRenderingContext2D`, an `OffscreenCanvasRenderingContext2D`
+ * and the contexts of the Node canvas libraries all have them. Members marked optional are used only when the context has them.
+ */
+export interface CanvasContext {
+    save(): void;
+    restore(): void;
+    setTransform(a: number, b: number, c: number, d: number, e: number, f: number): void;
+    beginPath(): void;
+    moveTo(x: number, y: number): void;
+    lineTo(x: number, y: number): void;
+    bezierCurveTo(c1x: number, c1y: number, c2x: number, c2y: number, x: number, y: number): void;
+    quadraticCurveTo(cx: number, cy: number, x: number, y: number): void;
+    closePath(): void;
+    fill(rule?: "nonzero" | "evenodd"): void;
+    stroke(): void;
+    clip(rule?: "nonzero" | "evenodd"): void;
+    fillText(text: string, x: number, y: number): void;
+    strokeText(text: string, x: number, y: number): void;
+    fillRect?(x: number, y: number, w: number, h: number): void;
+    clearRect?(x: number, y: number, w: number, h: number): void;
+    setLineDash(segments: number[]): void;
+    createLinearGradient?(x0: number, y0: number, x1: number, y1: number): CanvasGradientLike;
+    drawImage?(image: never, x: number, y: number, w: number, h: number): void;
+    /** A colour, or a gradient (or, on a real context, a pattern, which is never written here). */
+    fillStyle: string | CanvasGradientLike | object;
+    strokeStyle: string | CanvasGradientLike | object;
+    lineWidth: number;
+    lineJoin: string;
+    lineCap: string;
+    globalAlpha: number;
+    font: string;
+    textAlign: string;
+    textBaseline: string;
+    /** CSS filters, where the context has them (a browser's). */
+    filter?: string;
+    letterSpacing?: string;
+}
+/** Where and how large a scene is drawn, and what is not in the scene. */
+export interface CanvasOptions extends SceneOptions {
+    /** The width the surface is drawn at, in the context's units (pixels). With a `height` too, the drawing is fitted inside and centred. */
+    width?: number;
+    height?: number;
+    /** Pixels for one unit of the drawing (a foot, for most). Instead of a width or a height. 1 when none of the three is given. */
+    scale?: number;
+    /** Where the drawing's top left corner goes. 0, 0. */
+    x?: number;
+    y?: number;
+    /** Fill the picture's box with this colour first. */
+    background?: string;
+    /** Clear the picture's box first (where the context can). */
+    clear?: boolean;
+    /** The picture for a team's logo: given the address in the drawing, it returns something the context's `drawImage` takes (a loaded `Image`, an `ImageBitmap`, a canvas), or nothing, and then that logo is left out. */
+    images?: (href: string) => unknown;
+}
+/** What `drawToCanvas` drew. */
+export interface Drawn {
+    /** The box the drawing took, in the context's units. */
+    width: number;
+    height: number;
+    /** Pixels for one unit of the drawing. */
+    scale: number;
+}
+/** The colour with an alpha: `rgb(...)` of a hex or rgb colour, or the colour itself when it cannot be read (and the alpha is 1). */
+export declare function withAlpha(color: string, alpha: number): string;
+/**
+ * Draw a scene (or the options of `drawKyogijo`, or an SVG the package wrote) onto a canvas context. Give a `width` or a `height` in pixels, or a `scale`; the
+ * drawing keeps its shape. Light or dark by `theme`. A team's logo is drawn only if `images` returns a picture for its address.
+ * @example
+ * ```ts
+ * import { drawToCanvas, type CanvasContext } from "@johnmorrisdotca/kyogijo-stadiums/canvas";
+ * // Any object with the context's members will do: this one only counts what is drawn.
+ * const counts: Record<string, number> = {};
+ * const ctx = new Proxy({} as CanvasContext, { get: (_, name: string) => () => void (counts[name] = (counts[name] ?? 0) + 1), set: () => true });
+ * const drawn = drawToCanvas(ctx, { sport: "nhl", id: "rink" }, { width: 800 });
+ * console.log(drawn.width, Math.round(drawn.height), counts.fill > 10);
+ * // 800 374 true
+ * ```
+ */
+export declare function drawToCanvas(ctx: CanvasContext, source: SceneSource, options?: CanvasOptions): Drawn;