@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.6.0

package/dist/atlas.d.ts

@@ -1,8 +1,11 @@
+import { type Hall, type HallSurface } from "./halls.ts";
 import type { PlaceAlias } from "./names.ts";
-/** What a place is: a ballpark (of `PARKS`) or a soccer ground (of `GROUNDS`). */
-export type PlaceKind = "park" | "ground";
-/** The sport a place is drawn for: baseball parks have a fence, soccer grounds a pitch. */
-export type PlaceSport = "baseball" | "soccer";
+import type { BudoSport, BudoStyle, DojoSpec } from "./types.ts";
+import type { Tenant, TenantSport } from "./tenants.ts";
+/** What a place is: a ballpark (of `PARKS`), a soccer ground (of `GROUNDS`), a hall of the budō (of `HALLS`: a dojo, an arena, a sumo hall) or a hockey and basketball arena (of `ARENAS`). */
+export type PlaceKind = "park" | "ground" | "hall" | "arena";
+/** The sport a place is drawn for: baseball parks have a fence, soccer grounds a pitch, the halls of the budō (`budo`) the mats, the dohyō or the range of their sports, and arenas an ice rink (`hockey`) and a court (`basketball`). */
+export type PlaceSport = "baseball" | "soccer" | "budo" | "hockey" | "basketball";
 /** `current` is a ground a club or a competition uses today, `past` one it has left, closed or pulled down. */
 export type PlaceStatus = "current" | "past";
 /** One place on the atlas: a ballpark or a soccer ground, with where it is and when it was in use. */
@@ -27,13 +30,18 @@ export interface Place {
         from: number;
         to: number;
     }[];
+    /** The sport it is first drawn for: a park's is baseball, a ground's soccer, an arena's hockey where an ice hockey club played there, else basketball. */
     sport: PlaceSport;
-    /** The leagues and competitions it is known for: `MLB`, `NPB`, `FIFA World Cup`, `FIFA Women's World Cup`. A club ground that staged none has none. */
+    /** Every sport it is drawn for: a park's and a ground's is its `sport` alone, an arena's is `hockey`, `basketball` or both (`TD Garden`), by the clubs that played there. */
+    sports: readonly PlaceSport[];
+    /** The leagues and competitions it is known for: the leagues of the park's club and of every club that has played its home matches there (`CFL` and `MLS` for BC Place, `MLB` and `CFL` for Montreal's Olympic Stadium), then the World Cups it staged (`FIFA World Cup`, `FIFA Women's World Cup`). A ground with no tenant that staged none has none. */
     leagues: readonly string[];
+    /** The clubs that play, or played, their home matches there, with the league and the years of each (see `tenantsOf`): the current ones first. A place no club is known to have called home has none. */
+    tenants: readonly Tenant[];
     /** ISO 3166-1 alpha-2: `US`. */
     country: string;
     city: string;
-    /** The club that plays in a park (`Boston Red Sox`); soccer grounds have none. */
+    /** The club that plays in a park (`Boston Red Sox`); soccer grounds and arenas have none (see `tenants`). */
     team?: string;
     /** Wikidata's coordinates (P625, CC0), in degrees. */
     lat: number;
@@ -45,32 +53,26 @@ export interface Place {
     to?: number;
     /** The Wikidata item (`Q49136`): the key to join a place to other data. */
     wikidata: string;
+    /** A hall of the budō (`kind: "hall"`): what it holds, how it came to be and the surfaces it offers (see `HALLS`). */
+    hall?: Hall;
+    /** True where Wikidata lists athletics among the sports of a soccer ground: a running track lies round its pitch (`drawKyogijo({ sport: "athletics", ground })`). Absent where Wikidata says nothing of it. */
+    track?: boolean;
 }
 /** What `placesBy` keeps: every field given must match. A list matches any of its members. */
 export interface PlaceFilter {
+    /** A sport a place is drawn for: an arena is found by `hockey` and by `basketball` if clubs of both played there. */
     sport?: PlaceSport | readonly PlaceSport[];
     kind?: PlaceKind | readonly PlaceKind[];
-    /** A league or competition from `Place.leagues`. */
+    /** A league or competition from `Place.leagues`: a tenant's league (`CFL`) or a tournament. */
     league?: string | readonly string[];
     /** ISO 3166-1 alpha-2. */
     country?: string | readonly string[];
     status?: PlaceStatus | readonly PlaceStatus[];
     /** Keep the places in use in this year. A year that is not known for a place (no `from`, no `to`) does not shut it out. */
     year?: number;
-    /** Words to find in any name (the everyday names, the aliases, the readings), the city or the club, ignoring case, accents, width and, in Japanese, hiragana or katakana; every word must be found. */
+    /** Words to find in any name (the everyday names, the aliases, the readings), the city or the club, or the name of a club that plays or played there (in English or in Japanese), ignoring case, accents, width and, in Japanese, hiragana or katakana; every word must be found. */
     text?: string;
 }
-/**
- * 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 declare const PLACES: readonly Place[];
 /** The place with a key, or `undefined`. */
 export declare const placeById: (id: string | undefined) => Place | undefined;
@@ -116,16 +118,108 @@ export interface AtlasFacets {
  * ```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
+ * console.log(sports.join(), leagues.length, leagues.includes("CFL"), countries.length, years.min);
+ * // baseball,basketball,budo,hockey,soccer 90 true 23 1877
  * ```
  */
 export declare function atlasFacets(): AtlasFacets;
-/** The options `drawKyogijo` takes to draw a place's surface: a park's fence or a ground's pitch at its own size. */
+/** The options `drawKyogijo` takes to draw a surface a place offers. */
+export type PlaceSurface = {
+    sport: BudoSport;
+    league?: string;
+    budo?: BudoStyle;
+    dojo?: DojoSpec;
+} | {
+    sport: "mlb";
+    park: string;
+} | {
+    sport: "soccer";
+    ground?: string;
+} | {
+    sport: "nhl" | "nba";
+    arena?: string;
+} | {
+    sport: "nfl" | "cfl" | "afl" | "cricket";
+} | {
+    sport: "rugby";
+    league?: "nrl";
+};
+/** The sports `surfaceOf` can be asked for. */
+export type SurfaceSport = PlaceSurface["sport"];
+/**
+ * Every surface a hall of the budō offers, each with its name, how much of it is documented (`basis`) and the options that draw it, in the order of the hall's own list. A place that is not a hall has none.
+ * @example
+ * ```ts
+ * import { hallSurfaces, placeById } from "@johnmorrisdotca/kyogijo-stadiums/atlas";
+ * console.log(hallSurfaces(placeById("kodokan")!).map((surface) => `${surface.id} ${surface.mats}`).join());
+ * // main-dojo 420,main-dojo-earlier 420,school-dojo 240,international-dojo 192,womens-dojo 240,boys-dojo 114
+ * ```
+ */
+export declare const hallSurfaces: (place: Place) => readonly HallSurface[];
+/**
+ * Every surface a place offers, the place's own first: a park's fence (`mlb` with the park) or a ground's pitch at its size (`soccer` with the ground), then one for each
+ * sport a tenant plays that the package draws (a CFL field for BC Place, an NFL field for MetLife Stadium, the rugby league field for Stadium Australia), each once. A ground
+ * offers no ballpark, since its fence is not known; a park that a soccer club has played in offers the pitch at the international size, since its length and width are not known.
+ * @example
+ * ```ts
+ * import { placeById, surfacesOf } from "@johnmorrisdotca/kyogijo-stadiums/atlas";
+ * console.log(surfacesOf(placeById("bc-place")!).map((surface) => surface.sport).join());
+ * // soccer,cfl
+ * ```
+ */
+export declare function surfacesOf(place: Place): PlaceSurface[];
+/**
+ * The options `drawKyogijo` takes to draw a place's surface. With no sport, the place's own: a park's fence or a ground's pitch at its own size. With a sport (the `sport` of
+ * `drawKyogijo`: `cfl`, `nfl`, `mlb`, `soccer`, `nba`, `nhl`, `rugby`, `afl`, `cricket`), the surface the place offers for it (`surfacesOf`), or `undefined` when no club that plays
+ * that sport has played there: `surfaceOf(bcPlace, "cfl")` is `{ sport: "cfl" }` and `surfaceOf(fenwayPark, "cfl")` is `undefined`.
+ * @example
+ * ```ts
+ * import { placeById, surfaceOf } from "@johnmorrisdotca/kyogijo-stadiums/atlas";
+ * const bcPlace = placeById("bc-place")!;
+ * console.log(surfaceOf(bcPlace), surfaceOf(bcPlace, "cfl"), surfaceOf(bcPlace, "mlb"));
+ * // { sport: 'soccer', ground: 'bc-place' } { sport: 'cfl' } undefined
+ * ```
+ */
 export declare function surfaceOf(place: Place): {
     sport: "mlb";
     park: string;
 } | {
     sport: "soccer";
     ground: string;
-};
+} | {
+    sport: "nhl" | "nba";
+    arena: string;
+} | PlaceSurface;
+export declare function surfaceOf(place: Place, sport: SurfaceSport): PlaceSurface | undefined;
+/** What `tenantsOf` keeps: every field given must match. */
+export interface TenantFilter {
+    /** Keep the clubs that played there in this year. A bound the data does not give does not shut a club out. */
+    year?: number;
+    league?: string | readonly string[];
+    sport?: TenantSport | readonly TenantSport[];
+    /** `true` keeps the clubs that play there still (no last year), `false` those that have left. */
+    current?: boolean;
+}
+/**
+ * The clubs that play, or played, their home matches in a place, the current ones first (by the year they came) and then those that have left (the latest to leave first).
+ * Give a place, or its key.
+ * @example
+ * ```ts
+ * import { placeById, tenantsOf } from "@johnmorrisdotca/kyogijo-stadiums/atlas";
+ * const expos = tenantsOf("olympic-stadium-montreal").map((t) => `${t.club} (${t.league}) ${t.from}-${t.to ?? ""}`);
+ * console.log(expos[0], tenantsOf(placeById("bc-place")!, { current: true }).map((t) => t.club).join(", "));
+ * // Montreal Expos (MLB) 1977-2004 BC Lions, Vancouver Whitecaps FC
+ * ```
+ */
+export declare function tenantsOf(place: Place | string | undefined, filter?: TenantFilter): Tenant[];
+/**
+ * The places a club plays, or played, its home matches in, best match first: a club whose name is the one given (ignoring case, accents, spaces and punctuation, width, and in
+ * Japanese hiragana or katakana), then a club whose name has every word given in it (`whitecaps`, `lions`, `ライオンズ`); the names are the club's in English and in Japanese.
+ * @example
+ * ```ts
+ * import { placesByClub } from "@johnmorrisdotca/kyogijo-stadiums/atlas";
+ * console.log(placesByClub("BC Lions").map((place) => place.id).join(), placesByClub("Montreal Expos").map((place) => place.id).join());
+ * // bc-place jarry-park-stadium,olympic-stadium-montreal
+ * ```
+ */
+export declare function placesByClub(name: string | undefined): Place[];

package/dist/atlas.js

@@ -1,6 +1,9 @@
+import { ARENAS, ARENA_IDS } from "./arenas.js";
 import { GROUNDS, GROUND_IDS } from "./grounds.js";
+import { HALLS } from "./halls.js";
 import { nameContainsAll, placesNamed, plainName } from "./names.js";
 import { PARKS, PARK_IDS } from "./parks.js";
+import { SURFACE_OF_SPORT, TENANTS, hasSurface, leaguesOf, playedIn } from "./tenants.js";
 const leaguesOfGround = (ground) => {
     const leagues = [];
     if (ground.tournaments.some((t) => t.competition === "world-cup"))
@@ -9,7 +12,9 @@ const leaguesOfGround = (ground) => {
         leagues.push("FIFA Women's World Cup");
     return leagues;
 };
+const withoutRepeats = (...lists) => [...new Set(lists.flat())];
 const fromPark = (park) => {
+    const tenants = TENANTS[park.id] ?? [];
     const from = park.from ?? park.opened;
     const to = park.to ?? park.closed;
     return {
@@ -21,7 +26,9 @@ const fromPark = (park) => {
         ...(park.localName === undefined ? {} : { localName: park.localName, localLanguage: park.localLanguage }),
         aliases: park.aliases ?? [],
         sport: "baseball",
-        leagues: [park.league],
+        sports: ["baseball"],
+        leagues: withoutRepeats([park.league], leaguesOf(tenants)),
+        tenants,
         country: park.country,
         city: park.city,
         team: park.team,
@@ -44,7 +51,9 @@ const fromGround = (ground) => ({
     aliases: ground.aliases ?? [],
     ...(ground.names === undefined ? {} : { names: ground.names }),
     sport: "soccer",
-    leagues: leaguesOfGround(ground),
+    sports: ["soccer"],
+    leagues: withoutRepeats(leaguesOf(TENANTS[ground.id] ?? []), leaguesOfGround(ground)),
+    tenants: TENANTS[ground.id] ?? [],
     country: ground.country,
     city: ground.city,
     lat: ground.lat,
@@ -53,10 +62,46 @@ const fromGround = (ground) => ({
     ...(ground.from === undefined ? {} : { from: ground.from }),
     ...(ground.status === "past" && ground.to !== undefined ? { to: ground.to } : {}),
     wikidata: ground.wikidata,
+    ...(ground.track === true ? { track: true } : {}),
 });
+/** The sports an arena is drawn for, by the clubs that played there: hockey first when any ice hockey club did. */
+const sportsOfArena = (tenants) => {
+    const out = [];
+    if (tenants.some((tenant) => tenant.sport === "ice-hockey" && hasSurface(tenant)))
+        out.push("hockey");
+    if (tenants.some((tenant) => tenant.sport === "basketball" && hasSurface(tenant)))
+        out.push("basketball");
+    return out;
+};
+const fromArena = (arena) => {
+    const tenants = TENANTS[arena.id] ?? [];
+    const sports = sportsOfArena(tenants);
+    return {
+        id: arena.id,
+        kind: "arena",
+        name: arena.name,
+        nameJa: arena.nameJa,
+        ...(arena.readingJa === undefined ? {} : { readingJa: arena.readingJa }),
+        ...(arena.localName === undefined ? {} : { localName: arena.localName, localLanguage: arena.localLanguage }),
+        aliases: arena.aliases ?? [],
+        ...(arena.names === undefined ? {} : { names: arena.names }),
+        sport: sports[0] ?? "hockey",
+        sports: sports.length === 0 ? ["hockey"] : sports,
+        leagues: leaguesOf(tenants),
+        tenants,
+        country: arena.country,
+        city: arena.city,
+        lat: arena.lat,
+        lon: arena.lon,
+        status: arena.status,
+        ...(arena.from === undefined ? {} : { from: arena.from }),
+        ...(arena.status === "past" && arena.to !== undefined ? { to: arena.to } : {}),
+        wikidata: arena.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.
+ * Every place the package draws, parks first, then grounds, then arenas, each in the order of its own list: the ballparks of
+ * `PARKS`, the soccer grounds of `GROUNDS` and the hockey and basketball arenas of `ARENAS`, with where each stands.
  * @example
  * ```ts
  * import { PLACES } from "@johnmorrisdotca/kyogijo-stadiums/atlas";
@@ -65,7 +110,27 @@ const fromGround = (ground) => ({
  * // 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 fromHall = (hall) => ({
+    id: hall.id,
+    kind: "hall",
+    name: hall.name,
+    nameJa: hall.nameJa,
+    ...(hall.readingJa === undefined ? {} : { readingJa: hall.readingJa }),
+    aliases: hall.aliases,
+    sport: "budo",
+    sports: ["budo"],
+    leagues: hall.leagues,
+    tenants: [],
+    country: hall.country,
+    city: hall.city,
+    lat: hall.lat,
+    lon: hall.lon,
+    status: "current",
+    from: hall.from,
+    wikidata: hall.wikidata,
+    hall,
+});
+export const PLACES = Object.freeze([...PARK_IDS.map((id) => fromPark(PARKS[id])), ...GROUND_IDS.map((id) => fromGround(GROUNDS[id])), ...HALLS.map(fromHall), ...ARENA_IDS.map((id) => fromArena(ARENAS[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));
@@ -104,7 +169,7 @@ export function placesBy(filter = {}) {
     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))
+        if (sports !== undefined && !place.sports.some((sport) => sports.includes(sport)))
             return false;
         if (kinds !== undefined && !kinds.includes(place.kind))
             return false;
@@ -118,7 +183,9 @@ export function placesBy(filter = {}) {
             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])))
+            // A word may be in the name of any one club that played there.
+            const clubs = place.tenants.map((tenant) => plain([tenant.club, tenant.clubJa, ...(tenant.aliasesJa ?? [])].filter(Boolean).join(" ")));
+            if (!words.every((word) => haystack.includes(word) || nameContainsAll(place, [word]) || clubs.some((club) => club.includes(word))))
                 return false;
         }
         return true;
@@ -130,8 +197,8 @@ export function placesBy(filter = {}) {
  * ```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
+ * console.log(sports.join(), leagues.length, leagues.includes("CFL"), countries.length, years.min);
+ * // baseball,basketball,budo,hockey,soccer 90 true 23 1877
  * ```
  */
 export function atlasFacets() {
@@ -143,7 +210,125 @@ export function atlasFacets() {
         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 };
+/** The rink (`hockey`) or the court (`basketball`) of an arena, drawn at the arena's own size where the data has one. */
+const arenaSurface = (place, sport) => ({ sport: sport === "basketball" ? "nba" : "nhl", arena: place.id });
+/** The options that draw a surface of a hall. */
+const hallOptions = (surface) => ({ sport: surface.sport, ...surface.options });
+/**
+ * Every surface a hall of the budō offers, each with its name, how much of it is documented (`basis`) and the options that draw it, in the order of the hall's own list. A place that is not a hall has none.
+ * @example
+ * ```ts
+ * import { hallSurfaces, placeById } from "@johnmorrisdotca/kyogijo-stadiums/atlas";
+ * console.log(hallSurfaces(placeById("kodokan")!).map((surface) => `${surface.id} ${surface.mats}`).join());
+ * // main-dojo 420,main-dojo-earlier 420,school-dojo 240,international-dojo 192,womens-dojo 240,boys-dojo 114
+ * ```
+ */
+export const hallSurfaces = (place) => (place.kind === "hall" ? (place.hall?.surfaces ?? []) : []);
+/**
+ * Every surface a place offers, the place's own first: a park's fence (`mlb` with the park) or a ground's pitch at its size (`soccer` with the ground), then one for each
+ * sport a tenant plays that the package draws (a CFL field for BC Place, an NFL field for MetLife Stadium, the rugby league field for Stadium Australia), each once. A ground
+ * offers no ballpark, since its fence is not known; a park that a soccer club has played in offers the pitch at the international size, since its length and width are not known.
+ * @example
+ * ```ts
+ * import { placeById, surfacesOf } from "@johnmorrisdotca/kyogijo-stadiums/atlas";
+ * console.log(surfacesOf(placeById("bc-place")!).map((surface) => surface.sport).join());
+ * // soccer,cfl
+ * ```
+ */
+export function surfacesOf(place) {
+    if (place.kind === "hall")
+        return (place.hall?.surfaces ?? []).map(hallOptions);
+    // An arena's surfaces are its rink and its court, each at the arena's own size where the sources publish one.
+    const own = place.kind === "park" ? { sport: "mlb", park: place.id } : place.kind === "arena" ? arenaSurface(place, place.sport) : { sport: "soccer", ground: place.id };
+    const out = [own];
+    if (place.kind === "arena")
+        for (const sport of place.sports)
+            if (sport !== place.sport)
+                out.push(arenaSurface(place, sport));
+    for (const tenant of place.tenants) {
+        const drawn = SURFACE_OF_SPORT[tenant.sport];
+        if (drawn === undefined || !hasSurface(tenant))
+            continue;
+        // A baseball club's fence is a park's: a ground has none to draw.
+        if (drawn.sport === "mlb")
+            continue;
+        // An arena's rink and court are already offered, at its size.
+        if (place.kind === "arena" && (drawn.sport === "nhl" || drawn.sport === "nba"))
+            continue;
+        const surface = drawn.sport === "soccer" ? { sport: "soccer" } : drawn.sport === "rugby" ? { sport: "rugby", ...(drawn.league === undefined ? {} : { league: drawn.league }) } : { sport: drawn.sport };
+        if (out.some((have) => have.sport === surface.sport && (have.sport !== "rugby" || have.league === surface.league)))
+            continue;
+        out.push(surface);
+    }
+    return out;
+}
+export function surfaceOf(place, sport) {
+    if (place.kind === "hall")
+        return sport === undefined ? surfacesOf(place)[0] : surfacesOf(place).find((surface) => surface.sport === sport);
+    if (sport === undefined)
+        return place.kind === "park" ? { sport: "mlb", park: place.id } : place.kind === "arena" ? arenaSurface(place, place.sport) : { sport: "soccer", ground: place.id };
+    return surfacesOf(place).find((surface) => surface.sport === sport);
+}
+/**
+ * The clubs that play, or played, their home matches in a place, the current ones first (by the year they came) and then those that have left (the latest to leave first).
+ * Give a place, or its key.
+ * @example
+ * ```ts
+ * import { placeById, tenantsOf } from "@johnmorrisdotca/kyogijo-stadiums/atlas";
+ * const expos = tenantsOf("olympic-stadium-montreal").map((t) => `${t.club} (${t.league}) ${t.from}-${t.to ?? ""}`);
+ * console.log(expos[0], tenantsOf(placeById("bc-place")!, { current: true }).map((t) => t.club).join(", "));
+ * // Montreal Expos (MLB) 1977-2004 BC Lions, Vancouver Whitecaps FC
+ * ```
+ */
+export function tenantsOf(place, filter = {}) {
+    const found = typeof place === "string" ? BY_ID.get(place) : place;
+    if (found === undefined)
+        return [];
+    const leagues = many(filter.league);
+    const sports = many(filter.sport);
+    const year = filter.year !== undefined && Number.isFinite(filter.year) ? filter.year : undefined;
+    return found.tenants.filter((tenant) => {
+        if (leagues !== undefined && !leagues.includes(tenant.league))
+            return false;
+        if (sports !== undefined && !sports.includes(tenant.sport))
+            return false;
+        if (filter.current !== undefined && (tenant.to === undefined) !== filter.current)
+            return false;
+        return year === undefined || playedIn(tenant, year);
+    });
+}
+/**
+ * The places a club plays, or played, its home matches in, best match first: a club whose name is the one given (ignoring case, accents, spaces and punctuation, width, and in
+ * Japanese hiragana or katakana), then a club whose name has every word given in it (`whitecaps`, `lions`, `ライオンズ`); the names are the club's in English and in Japanese.
+ * @example
+ * ```ts
+ * import { placesByClub } from "@johnmorrisdotca/kyogijo-stadiums/atlas";
+ * console.log(placesByClub("BC Lions").map((place) => place.id).join(), placesByClub("Montreal Expos").map((place) => place.id).join());
+ * // bc-place jarry-park-stadium,olympic-stadium-montreal
+ * ```
+ */
+export function placesByClub(name) {
+    if (name === undefined)
+        return [];
+    const wanted = plain(name);
+    const words = name.split(/\s+/).map(plain).filter(Boolean);
+    if (wanted === "")
+        return [];
+    const ranked = [];
+    PLACES.forEach((place, index) => {
+        let best;
+        for (const tenant of place.tenants) {
+            for (const club of [tenant.club, tenant.clubJa, ...(tenant.aliasesJa ?? [])]) {
+                if (club === undefined)
+                    continue;
+                const own = plain(club);
+                const rank = own === wanted ? 0 : words.every((word) => own.includes(word)) ? 1 : undefined;
+                if (rank !== undefined && (best === undefined || rank < best))
+                    best = rank;
+            }
+        }
+        if (best !== undefined)
+            ranked.push([best, index, place]);
+    });
+    return ranked.sort((a, b) => a[0] - b[0] || a[1] - b[1]).map((row) => row[2]);
 }

package/dist/background.js

@@ -1,7 +1,8 @@
 // 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 { safeColour } from "./colour.js";
+import { safeLogo } from "./logo.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"];

package/dist/budo/describe.d.ts

@@ -0,0 +1,13 @@
+import type { Language, SurfaceOptions, Team } from "../types.ts";
+import type { DojoFigures } from "../leagues/budo.ts";
+import { type BudoPlan } from "./plan.ts";
+type Opt = Pick<SurfaceOptions, "sport" | "league" | "budo" | "dojo" | "range" | "detail">;
+/** The sentence about the surface, as a fragment: "a judo contest area of 10 by 10 metres in a safety area 4 metres wide...". */
+export declare function budoAbout(o: Opt, language: Language, plan?: BudoPlan): string;
+/** The sentences that follow it: what the options mark. Each starts after a gap. */
+export declare function budoSentences(o: Opt, language: Language, plan?: BudoPlan): string;
+/** The mat of a dojo league, for a caller that wants its size in words. */
+export declare const dojoMat: (f: DojoFigures) => string;
+/** What each side scored, in sentences, for a judo, karate, kendo or sumo score: the counts the board shows. Each starts after a gap. */
+export declare function budoScoreSentences(sport: string, order: readonly Pick<Team, "name" | "budo">[], language: Language): string;
+export {};

package/dist/budo/describe.js

@@ -0,0 +1,120 @@
+// What a budō drawing says of itself: its sentence about the surface, and what the options mark on it. Built from the plan, so that the words and the drawing agree.
+import { fill, KYOGIJO_STRINGS } from "../strings.js";
+import { budoView } from "../budo.score.js";
+import { kimariteName } from "./kimarite.js";
+import { budoPlan } from "./plan.js";
+const trim = (n) => String(Math.round(n * 100) / 100);
+const cm = (n) => String(Math.round(n * 1000) / 10);
+/** The sentence about the surface, as a fragment: "a judo contest area of 10 by 10 metres in a safety area 4 metres wide...". */
+export function budoAbout(o, language, plan = budoPlan(o)) {
+    const words = KYOGIJO_STRINGS[language].budo;
+    const mat = (m) => fill(words.tatami, { length: trim(m.length), width: trim(m.width) });
+    if (plan.judo !== undefined) {
+        const L = plan.judo;
+        const c = L.contests[0];
+        const contest = trim(c.x1 - c.x0);
+        const safety = trim(c.x0);
+        const tatami = mat(L.mat);
+        if (plan.league === "ijf-kata")
+            return fill(words.judoKata, { contest, safety, tatami });
+        return L.contests.length > 1 ? fill(words.judoMany, { areas: L.contests.length, contest, safety, gap: trim(L.gap), tatami }) : fill(words.judo, { contest, safety, tatami });
+    }
+    if (plan.karate !== undefined) {
+        const L = plan.karate;
+        const area = trim(L.areas[0].x1 - L.areas[0].x0);
+        const safety = trim(L.areas[0].x0);
+        if (plan.league === "wkf-kata")
+            return fill(words.karateKata, { area, safety });
+        return L.areas.length > 1 ? fill(words.karateMany, { areas: L.areas.length, area, gap: trim(L.gap), safety }) : fill(words.karate, { area, safety });
+    }
+    if (plan.kendo !== undefined)
+        return fill(words.kendo, { side: trim(plan.kendo.side) });
+    if (plan.sumo !== undefined) {
+        const L = plan.sumo;
+        const fig = plan.figures;
+        const bare = !L.parts.areas.some((a) => a.id === "tawara");
+        return fill(bare ? words.sumoBare : words.sumo, { platform: trim(fig.platform), height: cm(L.height), circle: trim(fig.circle), count: fig.tawara.count });
+    }
+    if (plan.kyudo !== undefined) {
+        const L = plan.kyudo;
+        const fig = plan.figures;
+        return fill(plan.league === "enteki" ? words.kyudoEnteki : words.kyudo, { n: L.shooters, distance: trim(fig.distance) });
+    }
+    const L = plan.dojo;
+    if (L === undefined)
+        return "";
+    const template = L.pattern === "competition" ? words.dojoCompetition : L.pattern === "checker" ? words.dojoChecker : L.pattern === "border" ? words.dojoBorder : words.dojoTraditional;
+    return fill(template, { jo: trim(L.jo), width: trim(L.width), length: trim(L.length), mat: fill(words.tatami, { length: trim(L.mat.length), width: trim(L.mat.width) }) });
+}
+/** The sentences that follow it: what the options mark. Each starts after a gap. */
+export function budoSentences(o, language, plan = budoPlan(o)) {
+    const words = KYOGIJO_STRINGS[language].budo;
+    const { gap } = KYOGIJO_STRINGS[language].said;
+    const out = [];
+    if (plan.judo !== undefined) {
+        const L = plan.judo;
+        const fig = plan.figures;
+        if (L.danger > 0)
+            out.push(words.danger);
+        if (o.budo?.platform === true)
+            out.push(words.platform);
+        if (plan.shapes.some((s) => s.kind === "bar" && s.feature.startsWith("start")) && fig.marks !== null)
+            out.push(fill(words.start, { apart: trim(2 * fig.marks.fromCentre) }));
+        if (o.budo?.officials === true)
+            out.push(words.officials);
+    }
+    if (plan.karate !== undefined && plan.areas.some((a) => a.feature === "judges" || a.feature === "referee"))
+        out.push(words.karateOfficials);
+    if (plan.sumo !== undefined && plan.areas.some((a) => a.feature === "tassels"))
+        out.push(words.tassels);
+    if (plan.dojo !== undefined) {
+        const L = plan.dojo;
+        out.push(fill(words.dojoKamiza, { side: words.sides[L.kamiza] }));
+        if (L.dais !== undefined)
+            out.push(words.dojoDais);
+        if (L.banner !== undefined)
+            out.push(words.dojoBanner);
+        if (L.shrine !== undefined)
+            out.push(words.dojoShinzen);
+        if (L.contests.length > 0)
+            out.push(fill(words.dojoAreas, { n: L.contests.length }));
+    }
+    return out.map((t) => `${gap}${t}`).join("");
+}
+/** The mat of a dojo league, for a caller that wants its size in words. */
+export const dojoMat = (f) => `${trim(f.mat.length)} × ${trim(f.mat.width)} m`;
+/** What each side scored, in sentences, for a judo, karate, kendo or sumo score: the counts the board shows. Each starts after a gap. */
+export function budoScoreSentences(sport, order, language) {
+    const words = KYOGIJO_STRINGS[language].budo;
+    const { gap } = KYOGIJO_STRINGS[language].said;
+    const sep = KYOGIJO_STRINGS[language].layers.listSep;
+    const out = [];
+    for (const team of order) {
+        const v = budoView(team.budo);
+        if (v === undefined)
+            continue;
+        const list = [];
+        const count = (n, label) => {
+            if (n !== undefined && n > 0)
+                list.push(language === "ja" ? `${label}${n}` : `${n} ${label.toLowerCase()}`);
+        };
+        if (sport === "judo" || sport === "karate") {
+            count(v.ippon, words.board.ippon);
+            count(v.wazaari, words.board.wazaari);
+            count(v.yuko, words.board.yuko);
+            count(v.shido, sport === "judo" ? words.board.shido : words.board.chui);
+            if (v.senshu === true)
+                list.push(words.board.senshu);
+            if (list.length > 0)
+                out.push(fill(sport === "judo" ? words.board.judoScore : words.board.karateScore, { name: team.name, list: list.join(sep) }));
+        }
+        else if (sport === "kendo" && v.techniques !== undefined) {
+            const named = v.techniques.map((t) => words.board.techniques[t] ?? t);
+            out.push(fill(words.board.kendoScore, { name: team.name, list: named.join(sep) }));
+        }
+        else if (sport === "sumo" && v.kimarite !== undefined) {
+            out.push(fill(words.board.sumoScore, { name: team.name, kimarite: kimariteName(v.kimarite, language) }));
+        }
+    }
+    return out.map((t) => `${gap}${t}`).join("");
+}