@johnmorrisdotca/kyogijo-stadiums 0.5.0 → 0.6.0

package/dist/arenas.js

@@ -0,0 +1,72 @@
+import { ARENA_DATA } from "./arenas.data.js";
+import { officialName, placesNamed } from "./names.js";
+const FEET_PER_METRE = 1 / 0.3048;
+const tenth = (feet) => Math.round(feet * 10) / 10;
+const inFeet = (size) => {
+    const k = size.unit === "m" ? FEET_PER_METRE : 1;
+    return { length: tenth(size.length * k), width: tenth(size.width * k) };
+};
+/** The size that held in a year: the one whose years cover it, else (with no year) the latest. */
+const sizeIn = (sizes, year) => {
+    if (sizes === undefined || sizes.length === 0)
+        return undefined;
+    if (year === undefined || !Number.isFinite(year))
+        return inFeet(sizes.find((size) => size.to === undefined) ?? sizes[sizes.length - 1]);
+    const found = sizes.find((size) => (size.from === undefined || size.from <= year) && (size.to === undefined || year <= size.to));
+    return found === undefined ? undefined : inFeet(found);
+};
+/**
+ * The size of an arena's rink in feet, in a year or today (the latest), when the sources publish one that differs from the NHL's; else `undefined` and the NHL's 200 by 85 feet
+ * is the rink.
+ * @example
+ * ```ts
+ * import { arenaById, arenaRinkIn } from "@johnmorrisdotca/kyogijo-stadiums/arenas";
+ * console.log(arenaRinkIn(arenaById("boston-garden")!), arenaRinkIn(arenaById("matthews-arena")!, 1926), arenaRinkIn(arenaById("td-garden")!));
+ * // { length: 190.9, width: 83 } { length: 220, width: 90 } undefined
+ * ```
+ */
+export const arenaRinkIn = (arena, year) => sizeIn(arena?.rink, year);
+/** The size of an arena's court in feet, in a year or today, when the sources publish one that differs from the NBA's 94 by 50 feet; else `undefined`. */
+export const arenaCourtIn = (arena, year) => sizeIn(arena?.court, year);
+/**
+ * Every arena by its key: the homes of the NHL's, the NBA's, the WNBA's and the PWHL's clubs, today's and the old ones, each with where it stands, when it was in use, its names,
+ * its seats for each sport and, where the sources publish one that differs from the league's, the size of its rink or its court.
+ * @example
+ * ```ts
+ * import { ARENAS } from "@johnmorrisdotca/kyogijo-stadiums/arenas";
+ * const garden = ARENAS["boston-garden"];
+ * console.log(garden.name, garden.city, garden.from, garden.to, garden.capacity?.hockey);
+ * // Boston Garden Boston 1928 1995 14448
+ * ```
+ */
+export const ARENAS = Object.freeze(Object.fromEntries(ARENA_DATA.map((data) => [data.id, data])));
+/** The keys of `ARENAS`, in the order of the data: the arenas in use first, then those of the past. */
+export const ARENA_IDS = Object.freeze(ARENA_DATA.map((data) => data.id));
+/** The arena with a key, or `undefined`. */
+export const arenaById = (id) => (id !== undefined && Object.prototype.hasOwnProperty.call(ARENAS, id) ? ARENAS[id] : undefined);
+/** The arenas that answer to a name, best match first (see `placesByName`): the everyday names, then the official and cited names, then the former names and the nicknames. */
+export const arenasByName = (name) => placesNamed(Object.values(ARENAS), name);
+/** The arena a name belongs to (the best match when several answer to it), or `undefined`. */
+export const arenaByName = (name) => arenasByName(name)[0];
+/** The arena whose Wikidata item is `Q894567`, or `undefined`. */
+export const arenaByWikidata = (wikidata) => Object.values(ARENAS).find((arena) => arena.wikidata === wikidata);
+/** The name an arena had in a year (the name of the time in English; in Japanese there is one name for every year). */
+export function arenaNameIn(arena, year, language = "en") {
+    if (language === "ja")
+        return arena.nameJa;
+    if (year === undefined || !Number.isFinite(year))
+        return arena.name;
+    const periods = (arena.names ?? []).filter((period) => period.from <= year && year <= period.to);
+    return periods.length === 0 ? arena.name : periods[periods.length - 1].name;
+}
+/** The name an arena officially has in a language, when it is not the everyday name; else `undefined`. */
+export function arenaOfficialName(arena, language = "en", year) {
+    const shown = arenaNameIn(arena, year, language);
+    if (year !== undefined && Number.isFinite(year) && language === "en" && shown !== arena.name)
+        return undefined;
+    return officialName(arena, language, shown, Number.isFinite(year) ? year : undefined);
+}
+/** The address of the revision of an article that an arena's facts were read from. */
+export function arenaSourceUrl(source, language = "en") {
+    return `https://${language}.wikipedia.org/w/index.php?title=${encodeURIComponent(source.title.replace(/ /g, "_"))}&oldid=${source.revision}`;
+}

package/dist/atlas-entry.d.ts

@@ -1,4 +1,6 @@
-export { PLACES, atlasFacets, placeById, placeByName, placesBy, placesByClub, placesByName, surfaceOf, surfacesOf, tenantsOf } from "./atlas.ts";
+export { PLACES, atlasFacets, hallSurfaces, placeById, placeByName, placesBy, placesByClub, placesByName, surfaceOf, surfacesOf, tenantsOf } from "./atlas.ts";
+export { HALLS } from "./halls.ts";
+export type { Hall, HallBasis, HallSurface } from "./halls.ts";
 export { officialName, plainName } from "./names.ts";
 export { TENANTS, TENANT_JAPANESE_NAMES, nameJaOf } from "./tenants.ts";
 export type { PlaceAlias, PlaceNameKind } from "./names.ts";

package/dist/atlas-entry.js

@@ -1,4 +1,5 @@
-// The atlas: every ballpark and soccer ground with where it stands, when it was in use and the clubs that played there, and the filters over them.
-export { PLACES, atlasFacets, placeById, placeByName, placesBy, placesByClub, placesByName, surfaceOf, surfacesOf, tenantsOf } from "./atlas.js";
+// The atlas: every ballpark, soccer ground and hockey and basketball arena, and the famous halls of the budō, with where it stands, when it was in use and the clubs that played there, and the filters over them.
+export { PLACES, atlasFacets, hallSurfaces, placeById, placeByName, placesBy, placesByClub, placesByName, surfaceOf, surfacesOf, tenantsOf } from "./atlas.js";
+export { HALLS } from "./halls.js";
 export { officialName, plainName } from "./names.js";
 export { TENANTS, TENANT_JAPANESE_NAMES, nameJaOf } from "./tenants.js";

package/dist/atlas.d.ts

@@ -1,9 +1,11 @@
+import { type Hall, type HallSurface } from "./halls.ts";
 import type { PlaceAlias } from "./names.ts";
+import type { BudoSport, BudoStyle, DojoSpec } from "./types.ts";
 import type { Tenant, TenantSport } from "./tenants.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";
+/** 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. */
@@ -28,7 +30,10 @@ 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;
+    /** 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. */
@@ -36,7 +41,7 @@ export interface Place {
     /** ISO 3166-1 alpha-2: `US`. */
     country: string;
     city: string;
-    /** The club that plays in a park (`Boston Red Sox`); soccer grounds have none (see `tenants`). */
+    /** 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;
@@ -48,11 +53,14 @@ 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 tenant's league (`CFL`) or a tournament. */
@@ -65,17 +73,6 @@ export interface PlaceFilter {
     /** 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;
@@ -122,25 +119,43 @@ export interface AtlasFacets {
  * import { atlasFacets } from "@johnmorrisdotca/kyogijo-stadiums/atlas";
  * const { sports, leagues, countries, years } = atlasFacets();
  * console.log(sports.join(), leagues.length, leagues.includes("CFL"), countries.length, years.min);
- * // baseball,soccer 83 true 23 1877
+ * // baseball,basketball,budo,hockey,soccer 90 true 23 1877
  * ```
  */
 export declare function atlasFacets(): AtlasFacets;
 /** 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: "nfl" | "cfl" | "nba" | "nhl" | "afl" | "cricket";
+    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
@@ -171,7 +186,10 @@ export declare function surfaceOf(place: Place): {
 } | {
     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 {

package/dist/atlas.js

@@ -1,4 +1,6 @@
+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";
@@ -24,6 +26,7 @@ const fromPark = (park) => {
         ...(park.localName === undefined ? {} : { localName: park.localName, localLanguage: park.localLanguage }),
         aliases: park.aliases ?? [],
         sport: "baseball",
+        sports: ["baseball"],
         leagues: withoutRepeats([park.league], leaguesOf(tenants)),
         tenants,
         country: park.country,
@@ -48,6 +51,7 @@ const fromGround = (ground) => ({
     aliases: ground.aliases ?? [],
     ...(ground.names === undefined ? {} : { names: ground.names }),
     sport: "soccer",
+    sports: ["soccer"],
     leagues: withoutRepeats(leaguesOf(TENANTS[ground.id] ?? []), leaguesOfGround(ground)),
     tenants: TENANTS[ground.id] ?? [],
     country: ground.country,
@@ -60,9 +64,44 @@ const fromGround = (ground) => ({
     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";
@@ -71,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));
@@ -110,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;
@@ -139,7 +198,7 @@ export function placesBy(filter = {}) {
  * import { atlasFacets } from "@johnmorrisdotca/kyogijo-stadiums/atlas";
  * const { sports, leagues, countries, years } = atlasFacets();
  * console.log(sports.join(), leagues.length, leagues.includes("CFL"), countries.length, years.min);
- * // baseball,soccer 83 true 23 1877
+ * // baseball,basketball,budo,hockey,soccer 90 true 23 1877
  * ```
  */
 export function atlasFacets() {
@@ -151,6 +210,20 @@ export function atlasFacets() {
         years: { min: Math.min(...years), max: Math.max(...years) },
     };
 }
+/** 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
@@ -163,8 +236,15 @@ export function atlasFacets() {
  * ```
  */
 export function surfacesOf(place) {
-    const own = place.kind === "park" ? { sport: "mlb", park: place.id } : { sport: "soccer", ground: place.id };
+    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))
@@ -172,6 +252,9 @@ export function surfacesOf(place) {
         // 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;
@@ -180,8 +263,10 @@ export function surfacesOf(place) {
     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 } : { sport: "soccer", ground: place.id };
+        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);
 }
 /**

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("");
+}

package/dist/budo/dojo.api.d.ts

@@ -0,0 +1,64 @@
+import type { SurfaceOptions } from "../types.ts";
+import type { MBox } from "./parts.ts";
+import type { Piece } from "./tatami.ts";
+import type { Compass, DojoPattern, DojoSpec } from "./types.ts";
+/** One mat of a dojo's floor, or a part of one, in metres from the floor's top left corner. */
+export type Tatami = Piece;
+/** A dojo made from a spec: the floor as data. */
+export interface Dojo {
+    /** The spec it was made from. */
+    spec: DojoSpec;
+    /** The mat standard: a league of the `dojo` sport (`chukyoma`, `kyoma`, `edoma`, `danchima`, `judo-2x1`) and the mat's size in metres. */
+    standard: string;
+    mat: {
+        length: number;
+        width: number;
+    };
+    /** The floor in metres: its width (x, the longer side) and its length (y). */
+    width: number;
+    length: number;
+    /** The floor's area in jō: the area over the area of a mat, a half mat counting a half. */
+    jo: number;
+    /** How many whole mats, half mats (hanjō) and cut pieces the floor holds. */
+    counts: {
+        full: number;
+        half: number;
+        cut: number;
+    };
+    pattern: DojoPattern;
+    /** Every mat, in metres, with the tone it is painted in (1, 2 or 3). */
+    mats: readonly Tatami[];
+    /** The seat of honour's wall, and the doors and windows with where each is. */
+    kamiza: Compass;
+    entrances: readonly {
+        wall: Compass;
+        box: MBox;
+    }[];
+    windows: readonly {
+        wall: Compass;
+        box: MBox;
+    }[];
+    shrine: MBox | undefined;
+    /** The thickness of the walls round the floor, 0 for none. */
+    wall: number;
+    /** The contest areas laid on the floor, in metres. */
+    contests: readonly MBox[];
+    /** The options that draw it: `drawKyogijo(dojo.options)`. */
+    options: SurfaceOptions;
+}
+/**
+ * A dojo (道場): the floor in mats, laid as real tatami units, with the walls, doors, windows, shrine and kamiza. `mats` is the floor: a number is its area in jō (8, 12, 20, 50, 100 and 200 give the usual shapes), `[across, along]`
+ * the whole mats across and along, `{ width, length, unit }` a size in metres, feet, mats or jō; `pattern` is how it is laid (`traditional`: no four corners meet; `competition`, `checker`, `border`).
+ * @example
+ * ```ts
+ * import { dojo } from "@johnmorrisdotca/kyogijo-stadiums/budo";
+ * const d = dojo({ jo: 20 });
+ * console.log(d.jo, d.width.toFixed(2), d.length.toFixed(2), d.counts.full, d.counts.half, d.pattern);
+ * // 20 7.28 4.55 18 4 traditional
+ * ```
+ */
+export declare function dojo(spec?: DojoSpec): Dojo;
+/** Draw a dojo: `drawKyogijo` with the spec as the options' `dojo`, and any other option the caller gives. */
+export declare function drawDojo(spec?: DojoSpec, more?: Partial<SurfaceOptions>): string;
+/** The mat standards a dojo can be laid with. */
+export declare const DOJO_STANDARDS: readonly string[];

package/dist/budo/dojo.api.js

@@ -0,0 +1,46 @@
+// The dojo builder's public face: `dojo(spec)` lays a floor of tatami out as real units and returns it as plain data (every mat, the floor in metres and in jō, where the kamiza, the doors and the windows are),
+// and `drawDojo(spec)` draws it. The same spec always gives the same floor.
+import { drawKyogijo } from "../draw.js";
+import { DOJO_LEAGUES } from "../leagues/budo.js";
+import { dojoLayout, dojoLeague } from "./dojo.js";
+/**
+ * A dojo (道場): the floor in mats, laid as real tatami units, with the walls, doors, windows, shrine and kamiza. `mats` is the floor: a number is its area in jō (8, 12, 20, 50, 100 and 200 give the usual shapes), `[across, along]`
+ * the whole mats across and along, `{ width, length, unit }` a size in metres, feet, mats or jō; `pattern` is how it is laid (`traditional`: no four corners meet; `competition`, `checker`, `border`).
+ * @example
+ * ```ts
+ * import { dojo } from "@johnmorrisdotca/kyogijo-stadiums/budo";
+ * const d = dojo({ jo: 20 });
+ * console.log(d.jo, d.width.toFixed(2), d.length.toFixed(2), d.counts.full, d.counts.half, d.pattern);
+ * // 20 7.28 4.55 18 4 traditional
+ * ```
+ */
+export function dojo(spec = {}) {
+    const standard = spec.standard ?? "chukyoma";
+    const league = dojoLeague(standard);
+    const L = dojoLayout(spec, league);
+    return {
+        spec,
+        standard,
+        mat: { length: L.mat.length, width: L.mat.width },
+        width: L.width,
+        length: L.length,
+        jo: L.jo,
+        counts: L.counts,
+        pattern: L.pattern,
+        mats: L.pieces,
+        kamiza: L.kamiza,
+        entrances: L.entrances,
+        windows: L.windows,
+        shrine: L.shrine,
+        wall: L.wall,
+        contests: L.contests,
+        options: { sport: "dojo", ...(standard === "chukyoma" ? {} : { league: standard }), dojo: spec },
+    };
+}
+/** Draw a dojo: `drawKyogijo` with the spec as the options' `dojo`, and any other option the caller gives. */
+export function drawDojo(spec = {}, more = {}) {
+    const d = dojo(spec);
+    return drawKyogijo({ ...d.options, ...more, sport: "dojo", dojo: spec });
+}
+/** The mat standards a dojo can be laid with. */
+export const DOJO_STANDARDS = DOJO_LEAGUES.map((l) => l.id);