@johnmorrisdotca/kyogijo-stadiums 0.49.1 → 0.51.0

package/dist/catalogue.js

@@ -0,0 +1,74 @@
+// The catalogue: every venue the package draws today (supported), the ones being built (working on) and the ones wanted, with their facts, in one list. The same data is published as a static
+// file, `catalogue.json`, in the npm package and on the demo's site (`CATALOGUE_ADDRESS`). There is no server: a reader fetches the file or imports this entry.
+import { CATALOGUE_DATA } from "./catalogue.data.js";
+/** Every venue: the supported ones first, then those being built, then the wanted ones, each group in its order. */
+export const CATALOGUE = CATALOGUE_DATA.venues;
+/** The leagues (every venue of the season, NBA, MLB, NFL, CFL and NHL) and the collections of the Working on and Wanted sections, each with its venues in order and its name in both languages. */
+export const CATALOGUE_GROUPS = CATALOGUE_DATA.groups;
+/** The sports, with their names in both languages and the `sport` of `drawKyogijo` that draws each (`null`: not drawn yet). */
+export const CATALOGUE_SPORTS = CATALOGUE_DATA.sports;
+/** The countries of the catalogue by ISO code, with their names in English and Japanese (Wikidata's labels). */
+export const CATALOGUE_COUNTRIES = CATALOGUE_DATA.countries;
+/** Where `catalogue.json` is published: the same data as this entry, for a page or a program that does not install the package. */
+export const CATALOGUE_ADDRESS = CATALOGUE_DATA.address;
+/** The demo's address: a supported venue's `demo` is relative to it. */
+export const CATALOGUE_SITE = CATALOGUE_DATA.site;
+/** The counts, the day the sources were read and where they are kept, and the licence of the facts. */
+export const CATALOGUE_ABOUT = {
+    schemaVersion: CATALOGUE_DATA.schemaVersion,
+    generatedAt: CATALOGUE_DATA.generatedAt,
+    package: CATALOGUE_DATA.package,
+    licence: CATALOGUE_DATA.licence,
+    source: CATALOGUE_DATA.source,
+    counts: CATALOGUE_DATA.counts,
+};
+const BY_ID = new Map(CATALOGUE.map((entry) => [entry.id, entry]));
+/**
+ * A venue by its id, or `undefined`.
+ * @example
+ * ```ts
+ * import { catalogueById } from "@johnmorrisdotca/kyogijo-stadiums/catalogue";
+ * const ashe = catalogueById("arthur-ashe-stadium")!;
+ * console.log(ashe.status, ashe.ticket, ashe.wikidata);
+ * // working-on KYOGIJO-STADIUMS-22 Q609551
+ * ```
+ */
+export function catalogueById(id) {
+    return BY_ID.get(id);
+}
+/** The venues of a status, in the catalogue's order. */
+export function catalogueByStatus(status) {
+    return CATALOGUE.filter((entry) => entry.status === status);
+}
+/** The venues of a sport (any of a venue's sports), in the catalogue's order. */
+export function catalogueBySport(sport) {
+    return CATALOGUE.filter((entry) => entry.sports.includes(sport));
+}
+/** The venues of a group (a league or a collection), in the group's order; empty for a group that does not exist. */
+export function catalogueByGroup(group) {
+    return (CATALOGUE_GROUPS.find((one) => one.id === group)?.ids ?? []).map((id) => BY_ID.get(id)).filter((entry) => entry !== undefined);
+}
+/** Every venue whose building or whole venue is wanted: the venues of the Wanted section and the supported venues of a league or a collection that are drawn as a surface only. */
+export function catalogueWanted() {
+    return CATALOGUE.filter((entry) => entry.want !== undefined && entry.status !== "working-on");
+}
+/**
+ * How much of a league the package draws: its venues this season, how many in their buildings, how many as a field only, how many not yet.
+ * @example
+ * ```ts
+ * import { catalogueCoverage } from "@johnmorrisdotca/kyogijo-stadiums/catalogue";
+ * const nhl = catalogueCoverage("nhl");
+ * console.log(nhl.venues, nhl.outline, nhl.notYet);
+ * // 32 32 0
+ * ```
+ */
+export function catalogueCoverage(league) {
+    const venues = catalogueByGroup(league);
+    return {
+        league,
+        venues: venues.length,
+        outline: venues.filter((entry) => entry.drawn === "outline").length,
+        surface: venues.filter((entry) => entry.drawn === "surface").length,
+        notYet: venues.filter((entry) => entry.status !== "supported").length,
+    };
+}

package/dist/catalogue.types.d.ts

@@ -0,0 +1,143 @@
+import type { PlaceSurface } from "./atlas.ts";
+/** Where a venue stands with the package: drawn today, being built (an open ticket), or wanted. */
+export type CatalogueStatus = "supported" | "working-on" | "wanted";
+/**
+ * How a supported venue is drawn: `outline`, inside the outline of its real building with a bowl of its seats (`STADIUMS` and the NHL's `VENUES`), or `surface`, its field, court, rink, park or
+ * floor only, at the venue's own size where the data gives one (a key of `PARKS`, `GROUNDS`, `ARENAS` or `HALLS`), or `circuit`, the lap as OpenStreetMap maps it with its pit lane and no stands
+ * (a key of `CIRCUITS`, drawn by `drawCircuit` of the `circuits` entry).
+ */
+export type CatalogueDrawn = "outline" | "surface" | "circuit";
+/** What is wanted of a venue: its building's `outline` (a venue drawn today as a surface only), or the `venue` itself (one the package does not draw at all). */
+export type CatalogueWant = "outline" | "venue";
+/** What has to exist before a wanted venue can be drawn: a `circuit-surface` for motor racing, which the package does not draw yet. */
+export type CatalogueNeed = "circuit-surface";
+/** The sports of the catalogue, in kebab case. Every one but `motor-racing` names a surface the package draws (`CATALOGUE_SPORTS[sport].surface`). */
+export type CatalogueSport = "baseball" | "basketball" | "hockey" | "american-football" | "canadian-football" | "soccer" | "cricket" | "rugby" | "australian-football" | "gaelic-games" | "tennis" | "budo" | "athletics" | "swimming" | "skating" | "curling" | "volleyball" | "badminton" | "handball" | "boxing" | "motor-racing";
+/** The leagues whose every venue of the season is in the catalogue. */
+export type CatalogueLeague = "nba" | "mlb" | "nfl" | "cfl" | "nhl";
+/** A club that plays its home games at a venue this season. */
+export interface CatalogueTeam {
+    name: string;
+    nameJa?: string;
+    league: CatalogueLeague;
+}
+/** The options that draw a supported venue with `drawKyogijo`: its surface (a park, a ground, an arena or a hall), or its real building (`stadium` or `arena` with `crowd: { real: true }`). */
+export type CatalogueDraw = PlaceSurface | {
+    sport: "nfl" | "cfl" | "soccer" | "mlb" | "boxing" | "nba" | "nhl";
+    stadium?: string;
+    park?: string;
+    arena?: string;
+    crowd: {
+        real: true;
+    };
+};
+/** One venue of the catalogue. */
+export interface CatalogueEntry {
+    /** Kebab case, unique: the package's own key for a venue it draws (`fenway-park`, `bc-place`), else one made from the venue's English name. */
+    id: string;
+    status: CatalogueStatus;
+    /** How a supported venue is drawn. */
+    drawn?: CatalogueDrawn;
+    /** What is wanted: the building's outline of a venue drawn as a surface that a league or a group lists, or the venue itself. */
+    want?: CatalogueWant;
+    /** What must be built first. */
+    needs?: CatalogueNeed;
+    /** Which of the package's lists a supported venue comes from: a real stadium or NHL venue (`stadium`, `venue`), or a `park`, `ground`, `arena` or `hall`. */
+    kind?: "stadium" | "venue" | "park" | "ground" | "arena" | "hall" | "circuit";
+    /** The everyday name in English. */
+    name: string;
+    /** The name in Japanese; absent where no source gives one (`missing.nameJa` says so). */
+    nameJa?: string;
+    /** Where the Japanese name was read: the package's own data, Wikidata's label, the title of the Japanese Wikipedia's article, or a name a reviewer checked. */
+    nameJaFrom?: "package" | "wikidata" | "jawiki" | "reviewed";
+    city?: string;
+    cityJa?: string;
+    /** ISO 3166-1 alpha-2. */
+    country?: string;
+    /** Wikidata's coordinates (P625), in degrees. */
+    lat?: number;
+    lon?: number;
+    sports: CatalogueSport[];
+    /** The Wikidata item. */
+    wikidata: string;
+    /** The seats, where Wikidata gives one figure (P1083), for a venue that is not drawn yet. */
+    capacity?: number;
+    /** `current` or `past`, for a supported venue. */
+    era?: "current" | "past";
+    /** The leagues that play there this season, and their clubs. */
+    leagues?: CatalogueLeague[];
+    teams?: CatalogueTeam[];
+    /** The groups the venue is listed in (a league, a collection of the Wanted section). */
+    groups: string[];
+    /** The ticket of a venue being built. */
+    ticket?: string;
+    /** The options that draw a supported venue with `drawKyogijo` (a circuit has none: `drawCircuit({ circuit: id })` of the `circuits` entry draws it). */
+    draw?: CatalogueDraw;
+    /** The demo page that shows a supported venue, relative to the demo's address (`CATALOGUE_SITE`). */
+    demo?: string;
+    /** The facts left out, each with why. */
+    missing?: Partial<Record<"nameJa" | "city" | "country" | "coordinates", string>>;
+}
+/** A group: a league (every venue of its season) or a collection of the Wanted or Working on section, in its order. */
+export interface CatalogueGroup {
+    id: string;
+    kind: "league" | "collection";
+    en: string;
+    ja: string;
+    /** For a league: its sport and its season. */
+    sport?: CatalogueSport;
+    season?: string;
+    /** For a collection that is being built. */
+    status?: "working-on";
+    needs?: CatalogueNeed;
+    ids: string[];
+}
+/** The whole catalogue, as `catalogue.json` holds it. */
+export interface CatalogueData {
+    /** The shape's version: a change that breaks a reader raises it. */
+    schemaVersion: 1;
+    /** The day the sources were read (not the day the file was written). */
+    generatedAt: string;
+    package: {
+        name: string;
+        version: string;
+    };
+    /** Where the JSON is published. */
+    address: string;
+    /** The demo's address, which `demo` is relative to. */
+    site: string;
+    licence: string;
+    source: {
+        read: string;
+        rawAnswers: string;
+        articles: Record<string, number>;
+    };
+    counts: {
+        supported: number;
+        outline: number;
+        surface: number;
+        circuit: number;
+        workingOn: number;
+        wanted: number;
+        outlineWanted: number;
+    };
+    sports: Record<CatalogueSport, {
+        en: string;
+        ja: string;
+        surface: string | null;
+    }>;
+    groups: CatalogueGroup[];
+    countries: Record<string, {
+        en: string;
+        ja?: string;
+    }>;
+    venues: CatalogueEntry[];
+}
+/** How many venues of a league the package draws in their buildings, as a surface only, or not at all. */
+export interface CatalogueCoverage {
+    league: CatalogueLeague;
+    venues: number;
+    outline: number;
+    surface: number;
+    notYet: number;
+}

package/dist/catalogue.types.js

@@ -0,0 +1 @@
+export {};

package/dist/circuits-entry.d.ts

@@ -0,0 +1,11 @@
+import "./strings.ts";
+export { CIRCUITS, CIRCUIT_ATTRIBUTION, CIRCUIT_IDS, circuitById, circuitPlan } from "./circuits.ts";
+export type { CircuitPlan, PlanTurn } from "./circuits.ts";
+export { circuitDrawing, circuitTable, circuitText, drawCircuit } from "./circuits.draw.ts";
+export type { CircuitDrawing } from "./circuits.draw.ts";
+export { CIRCUIT_MARKER, CIRCUIT_PLANES_MAX, CIRCUIT_PRESETS, buildCircuitTurn, circuitTurnMarkup, mountCircuitTurn } from "./circuits.turn.ts";
+export { KYOGIJO_CIRCUIT_STYLE } from "./circuits.style.ts";
+export { CIRCUIT_WORDS } from "./circuits.words.ts";
+export type { CircuitWords } from "./circuits.words.ts";
+export { lineLength } from "./circuits.geo.ts";
+export type { Circuit, CircuitBasis, CircuitData, CircuitFact, CircuitOptions, CircuitOsm, CircuitOsmPoint } from "./circuits.types.ts";

package/dist/circuits-entry.js

@@ -0,0 +1,9 @@
+// The circuits entry (`@johnmorrisdotca/kyogijo-stadiums/circuits`): famous race tracks as OpenStreetMap maps them, with a few facts each, drawn flat and in 3D.
+// The words of the 3D view's controls in both languages (the circuits' own are in circuits.words.ts).
+import "./strings.js";
+export { CIRCUITS, CIRCUIT_ATTRIBUTION, CIRCUIT_IDS, circuitById, circuitPlan } from "./circuits.js";
+export { circuitDrawing, circuitTable, circuitText, drawCircuit } from "./circuits.draw.js";
+export { CIRCUIT_MARKER, CIRCUIT_PLANES_MAX, CIRCUIT_PRESETS, buildCircuitTurn, circuitTurnMarkup, mountCircuitTurn } from "./circuits.turn.js";
+export { KYOGIJO_CIRCUIT_STYLE } from "./circuits.style.js";
+export { CIRCUIT_WORDS } from "./circuits.words.js";
+export { lineLength } from "./circuits.geo.js";

package/dist/circuits.d.ts

@@ -0,0 +1,62 @@
+import type { Pt } from "./crowd.ts";
+import type { Circuit } from "./circuits.types.ts";
+import { type LonLat } from "./venues.geo.ts";
+/** The credit a drawing made from OpenStreetMap's data carries (the same words as the venues'). */
+export declare const CIRCUIT_ATTRIBUTION = "(c) OpenStreetMap contributors, ODbL 1.0, openstreetmap.org/copyright";
+/** Every circuit, in the order of the data. */
+export declare const CIRCUITS: readonly Circuit[];
+/** The keys of the circuits. */
+export declare const CIRCUIT_IDS: readonly string[];
+/** A circuit by its key, or `undefined`. */
+export declare const circuitById: (id: string) => Circuit | undefined;
+/** A turn as the plan places it: its number, its point on the lap, how far round the lap it is, which way the lap runs there and the side the bend turns to (1 left, -1 right, 0 straight). */
+export interface PlanTurn {
+    n: number;
+    at: Pt;
+    along: number;
+    dir: Pt;
+    side: -1 | 0 | 1;
+}
+/** A circuit's plan in the drawing's frame: feet, the long side of the lap along x, y down the page. */
+export interface CircuitPlan {
+    circuit: Circuit;
+    /** The point of the map the frame is measured from (the middle of the lap's box), `[longitude, latitude]`. */
+    origin: LonLat;
+    /** The heading of the lap's long side, degrees clockwise from north, and the way north points on the page, degrees clockwise from its top. */
+    heading: number;
+    north: number;
+    lap: Pt[];
+    /** The length of the lap measured along the drawn line, in metres. */
+    measured: number;
+    pitLane: Pt[];
+    area: Pt[];
+    building?: {
+        ring: Pt[];
+        height: number;
+    };
+    turns: PlanTurn[];
+    start: {
+        at: Pt;
+        dir: Pt;
+        along: number;
+    };
+    finish: {
+        at: Pt;
+        dir: Pt;
+        along: number;
+    };
+    /** The track's width and the pit lane's, in feet. */
+    width: number;
+    pitWidth: number;
+    /** The box of everything drawn on the ground, in feet. */
+    box: {
+        x0: number;
+        y0: number;
+        x1: number;
+        y1: number;
+    };
+}
+/** A circuit's plan: its lap, pit lane, ground, pit building, turns, start and finish in the drawing's frame. */
+export declare function circuitPlan(circuit: Circuit): CircuitPlan;
+/** The circuit a set of options names, or an error that lists the keys. */
+export declare function circuitOf(id: string): Circuit;

package/dist/circuits.data.d.ts

@@ -0,0 +1,2 @@
+import type { CircuitData } from "./circuits.types.ts";
+export declare const CIRCUIT_DATA: CircuitData[];

package/dist/circuits.data.js

@@ -0,0 +1,18 @@
+export const CIRCUIT_DATA = [
+    {
+        "id": "las-vegas",
+        "wikidata": "Q113112116",
+        "en": { "title": "Las Vegas Strip Circuit", "revision": 1376988769 },
+        "ja": { "title": "ラスベガス・ストリップ・サーキット", "revision": 108197128 },
+        "names": { "en": "Las Vegas Strip Circuit", "ja": "ラスベガス・ストリップ・サーキット" },
+        "country": "US",
+        "opened": { "value": "2023-11-16", "basis": "documented", "source": "wikidata", "read": "P1619, date of official opening, 16 November 2023; the English article says it opened on November 16, 2023, and the Japanese infobox gives the same day" },
+        "length": { "value": 6201, "basis": "documented", "source": "wikipedia", "read": "the English infobox's length, 6.201 km (3.853 mi), which the Japanese infobox also gives; the Japanese article's prose says 6.120 km, which neither infobox nor the English article does, and is not used" },
+        "corners": { "value": 17, "basis": "documented", "source": "wikipedia", "read": "the English infobox's turns, 17, and its prose: 14 corners when announced, 17 after a chicane was added; the Japanese infobox gives 17 too" },
+        "direction": { "value": "counterclockwise", "basis": "documented", "source": "wikipedia", "read": "the English article: the street circuit runs counterclockwise; the Japanese article says the same (反時計回り)" },
+        "width": { "value": 12, "basis": "plausible", "read": "ours: no source we read gives the track's width (OpenStreetMap maps no width on the lap's ways, and neither article gives one), so the ribbon is drawn 12 metres wide" },
+        "pitLaneWidth": { "value": 8, "basis": "plausible", "read": "ours: no source gives the pit lane's width" },
+        "turnNumbers": { "basis": "documented", "source": "openstreetmap", "read": "the relation's member nodes tagged junction=yes with ref 1 to 17, one at each turn as OpenStreetMap maps them; the English article's account of the lap (Turn 1 a hairpin after the pits, Turns 10 and 11 on Sands Avenue, Turn 12 onto Las Vegas Boulevard, Turn 13 on the Strip, Turns 14 to 16 onto Harmon Avenue, Turn 17 before the pits) agrees with where they lie" },
+        "pitBuilding": { "basis": "documented", "source": "openstreetmap", "read": "the building OpenStreetMap maps inside the circuit's area beside the pit lane, 19.5 metres high in 4 levels (its height and building:levels tags)" },
+    },
+];

package/dist/circuits.draw.d.ts

@@ -0,0 +1,56 @@
+import type { Pt } from "./crowd.ts";
+import { type CircuitPlan } from "./circuits.ts";
+import type { CircuitOptions } from "./circuits.types.ts";
+import type { Language } from "./types.ts";
+/** A drawing of a circuit and what was worked out to make it. */
+export interface CircuitDrawing {
+    svg: string;
+    plan: CircuitPlan;
+    /** The viewBox, in feet. */
+    viewBox: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    /** The size of the drawing's type and marks: a thousandth of its longer side, in feet. */
+    k: number;
+    /** Where each turn's number is drawn (its badge's middle), in feet, or would be when `turns` is `false`. */
+    badges: {
+        n: number;
+        at: Pt;
+        r: number;
+    }[];
+    title: string;
+    description: string;
+}
+/** The words of a circuit's drawing: its title and its description, sentence by sentence. */
+export declare function circuitText(plan: CircuitPlan, language: Language, standing?: string): {
+    title: string;
+    description: string;
+};
+/** A circuit's drawing and what was worked out to make it. */
+export declare function circuitDrawing(options: CircuitOptions): CircuitDrawing;
+/**
+ * A circuit as one SVG string: the lap as a ribbon of the track's width on the ways OpenStreetMap maps for it, the pit lane and the circuit's ground with its pit building, the start and the chequered finish across the
+ * track, arrows the way the lap runs, each turn's number beside its bend where OpenStreetMap numbers it, a north arrow, a scale bar and the credit of the map's data. Light and dark follow the page.
+ * @example
+ * ```ts
+ * import { drawCircuit } from "@johnmorrisdotca/kyogijo-stadiums/circuits";
+ * const svg = drawCircuit({ circuit: "las-vegas" });
+ * console.log(svg.startsWith("<svg"), svg.includes('data-turn="17"'), svg.includes("OpenStreetMap"));
+ * // true true true
+ * ```
+ */
+export declare function drawCircuit(options: CircuitOptions): string;
+/**
+ * A circuit's facts as a table, each with its basis (a source's, or ours) and the length the drawn line measures: for a reader who cannot see the drawing, and for a page that wants the data.
+ * @example
+ * ```ts
+ * import { circuitTable } from "@johnmorrisdotca/kyogijo-stadiums/circuits";
+ * const table = circuitTable({ circuit: "las-vegas" });
+ * console.log(table.startsWith("<table"), table.includes("6.201 km"));
+ * // true true
+ * ```
+ */
+export declare function circuitTable(options: CircuitOptions): string;