@johnmorrisdotca/kyogijo-stadiums 0.28.0 → 0.31.0

package/dist/venue.real.js

@@ -1,5 +1,6 @@
 // The building of a real venue, raised: its walls, standing on the outline OpenStreetMap gives, and its roof over the top tier, a lid that rises towards the middle, a saddle that rises at the two ends and falls at the two
-// sides, or a cable-supported roof that rises to an opening over the surface which a retractable fabric closes (BC Place's, with the fabric gathered into its pod when `roofOpen` is asked). All are asked for with the roof
+// sides, a cable-supported roof that rises to an opening over the surface which a retractable fabric closes (BC Place's, with the fabric gathered into its pod when `roofOpen` is asked), canopies over some of the
+// stands that leave the field open (Lumen Field's), or retractable panels high over a ballpark (T-Mobile Park's, resting over its east side when `roofOpen` is asked). All are asked for with the roof
 // (`venue: { roof: true }`) and give way to the eye as the other walls do. Pure: data in, planes out.
 import { rayAt } from "./crowd.js";
 import { n, shy, wall } from "./turn.kit.js";
@@ -52,10 +53,10 @@ function slopeThrough(points) {
     return { x0: mx, y0: my, z0: mz, gx, gy };
 }
 /**
- * The walls and the roof of a real venue. The hall is the building's outline cut to the bowl's wall and a margin (`RealShell.hall`): its rim is where a ray from the middle meets the one or the other first, in `steps`
+ * The walls and the roof of a real venue (`parts` says which are made). The hall is the building's outline cut to the bowl's wall and a margin (`RealShell.hall`): its rim is where a ray from the middle meets the one or the other first, in `steps`
  * rays. A wall stands on each stretch of the rim, up to the roof's height over it; the roof is a band from the rim in to the inner edge of the top tier (the middle stays open, as the 3D view's roofs are).
  */
-export function realBuilding(real, top, centre, lift, steps, open = false) {
+export function realBuilding(real, top, centre, lift, steps, open = false, parts = { walls: true, roof: true }) {
     const items = [];
     const c = [centre[0], centre[1]];
     const rim = Array.from({ length: steps }, (_, k) => {
@@ -70,13 +71,25 @@ export function realBuilding(real, top, centre, lift, steps, open = false) {
         const long = Math.hypot(b[0] - a[0], b[1] - a[1]);
         if (long < 1)
             return;
-        const high = lift + roofAt(real, [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2]);
+        const high = lift + (real.wall ?? roofAt(real, [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2]));
         planes.push({ ...shy(wall(`shell-${i}`, "wall", a[0], a[1], b[0], b[1], 0, high, `<rect class="u-shell" width="${n(long)}" height="${n(high)}"/>`), centre), fadeTo: 0.02 });
     });
-    if (planes.length > 0)
+    if (parts.walls && planes.length > 0)
         items.push({ id: "shell", kind: "walls", at: centre, height: Math.max(...planes.map((p) => p.o[2])), planes });
+    if (parts.roof && real.roof === "canopy" && real.canopies !== undefined) {
+        const planes = canopyRoof(real.canopies, c, lift, steps);
+        if (planes.length > 0)
+            items.push({ id: "roof", kind: "roof", at: centre, height: heightOf(planes), planes });
+        return items;
+    }
+    if (parts.roof && real.roof === "panels" && real.panels !== undefined) {
+        const planes = panelsRoof(real.panels, c, lift, steps, open);
+        if (planes.length > 0)
+            items.push({ id: "roof", kind: "roof", at: centre, height: heightOf(planes), planes });
+        return items;
+    }
     const crown = real.roof === "cable" ? real.crown : undefined;
-    if (top?.hole == null && crown === undefined)
+    if (!parts.roof || (top?.hole == null && crown === undefined))
         return items;
     const roof = [];
     // A cable roof rises from the rim of the hall to the opening over the surface; any other is a band from the rim in to the inner edge of the top tier.
@@ -105,20 +118,121 @@ export function realBuilding(real, top, centre, lift, steps, open = false) {
             roof.push({ ...piece, shy: [(mid[0] - c[0]) / away, (mid[1] - c[1]) / away] });
     }
     if (crown !== undefined)
-        roof.push(...cablePod(real, crown, inner, c, lift, steps, open));
+        roof.push(...cablePod(lift + real.edge + crown.rise, inner, c, steps, open));
     if (roof.length > 0)
-        items.push({ id: "roof", kind: "roof", at: centre, height: Math.max(...roof.flatMap((p) => [p.o[2], p.o[2] + p.u[2], p.o[2] + p.v[2], p.o[2] + p.u[2] + p.v[2]])), planes: roof });
+        items.push({ id: "roof", kind: "roof", at: centre, height: heightOf(roof), planes: roof });
     return items;
 }
+/** The top of a set of planes. */
+const heightOf = (planes) => Math.max(...planes.flatMap((p) => [p.o[2], p.o[2] + p.u[2], p.o[2] + p.v[2], p.o[2] + p.u[2] + p.v[2]]));
+/** The two points where a ray from `from` first enters a polygon and last leaves it (the polygon is a band round the middle, so a ray crosses it once), or `undefined` where it misses. */
+function span(poly, from, angle) {
+    const [dx, dy] = [Math.cos(angle), Math.sin(angle)];
+    const hits = [];
+    poly.forEach(([ax, ay], i) => {
+        const [bx, by] = poly[(i + 1) % poly.length];
+        const [ex, ey] = [bx - ax, by - ay];
+        const den = dx * ey - dy * ex;
+        if (Math.abs(den) < 1e-12)
+            return;
+        const t = ((ax - from[0]) * ey - (ay - from[1]) * ex) / den;
+        const u = ((ax - from[0]) * dy - (ay - from[1]) * dx) / den;
+        if (t > 1e-6 && u >= 0 && u < 1)
+            hits.push(t);
+    });
+    if (hits.length < 2)
+        return undefined;
+    const [lo, hi] = [Math.min(...hits), Math.max(...hits)];
+    return [[from[0] + dx * lo, from[1] + dy * lo], [from[0] + dx * hi, from[1] + dy * hi]];
+}
+/**
+ * A piece of roof between two rays: the quad `[inner a, inner b, outer b, outer a]` at the heights given, as a plane that gives way to the eye. A quad whose edges are not parallel is not flat at those heights, so
+ * with `exact` it is two triangles, each a plane through its corners.
+ */
+function piece(id, quad, heights, c, cables, exact = false) {
+    const [ai, bi, b, a] = quad;
+    const [ex, ey] = [b[0] - a[0], b[1] - a[1]];
+    const el = Math.hypot(ex, ey);
+    if (el < 1e-6)
+        return [];
+    const make = (name, poly, hs, cable) => {
+        const slope = slopeThrough(poly.map((p, i) => [p[0], p[1], hs[i]]));
+        const mid = [poly.reduce((s, p) => s + p[0], 0) / poly.length, poly.reduce((s, p) => s + p[1], 0) / poly.length];
+        const away = Math.hypot(mid[0] - c[0], mid[1] - c[1]) || 1;
+        const paint = (corners) => `<polygon class="u-roof" points="${pointList(corners)}"/>${cable ? `<path class="u-cable" d="M${n(corners[0][0])} ${n(corners[0][1])}L${n(corners[3][0])} ${n(corners[3][1])}"/>` : ""}`;
+        const plane = raked(name, "roof", poly, slope, [ex / el, ey / el], paint);
+        return plane === undefined ? [] : [{ ...plane, shy: [(mid[0] - c[0]) / away, (mid[1] - c[1]) / away] }];
+    };
+    if (!exact)
+        return make(id, quad, heights, cables);
+    return [...make(`${id}a`, [ai, bi, b], [heights[0], heights[1], heights[2]], false), ...make(`${id}b`, [ai, b, a], [heights[0], heights[2], heights[3]], false)];
+}
+/** How far a canopy's low edge, the field's side of it, stands under its high edge: the OpenStreetMap roof's `roof:height` is the rise, and the canopy rises to the back of the stands (ours: the sources do not say which way it slopes). */
+export const CANOPY_NOTE = "low over the field, high over the back of the stands";
+/**
+ * Canopies over some of the stands (Lumen Field's two, one each side of the field): each OpenStreetMap roof outline is cut by the rays from the middle of the field into the strips between them, the edge towards
+ * the field low and the edge towards the back of the stands `rise` higher.
+ */
+function canopyRoof(canopies, c, lift, steps) {
+    const planes = [];
+    canopies.forEach((canopy, ci) => {
+        const spans = Array.from({ length: steps }, (_, k) => span(canopy.ring, c, (2 * Math.PI * k) / steps));
+        for (let k = 0; k < steps; k += 1) {
+            const [s, t] = [spans[k], spans[(k + 1) % steps]];
+            if (s === undefined || t === undefined)
+                continue;
+            const [lo, hi] = [lift + canopy.low, lift + canopy.low + canopy.rise];
+            planes.push(...piece(`roof-c${ci}-${k}`, [s[0], t[0], t[1], s[1]], [lo, lo, hi, hi], c, false, true));
+        }
+    });
+    return planes;
+}
+/** The share of a retractable roof's cover that the closed roof's flat crown takes (the sections meet in the middle at the crown's height). */
+const PANEL_CROWN = 0.3;
+/** How thick a parked section is, in feet (ours). */
+const PANEL_THICK = 7;
+/**
+ * A ballpark's retractable roof: closed, a band from the rim of its cover up to a crown over the middle with the fabric laid over the crown (as the cable roof's); open, only the sections resting over the side of the
+ * building they park on, as slabs at the rim's height.
+ */
+function panelsRoof(panels, c, lift, steps, open) {
+    const planes = [];
+    if (!open) {
+        const rim = Array.from({ length: steps }, (_, k) => firstHit(panels.cover, c, (2 * Math.PI * k) / steps) ?? c);
+        const inner = rim.map((p) => [c[0] + (p[0] - c[0]) * PANEL_CROWN, c[1] + (p[1] - c[1]) * PANEL_CROWN]);
+        for (let k = 0; k < steps; k += 1) {
+            const [a, b] = [rim[k], rim[(k + 1) % steps]];
+            const [ai, bi] = [inner[k], inner[(k + 1) % steps]];
+            const [lo, hi] = [lift + panels.bottom, lift + panels.top];
+            planes.push(...piece(`roof-${k}`, [ai, bi, b, a], [hi, hi, lo, lo], c, false, true));
+        }
+        // The crown itself: a flat cap over the middle, in the fabric's drawing.
+        planes.push(...cablePod(lift + panels.top, inner, c, steps, false));
+        return planes;
+    }
+    // Open: the parked sections as slabs.
+    const z = lift + panels.bottom;
+    const top = z + PANEL_THICK;
+    const slab = raked("parked-top", "roof", panels.parked, { x0: panels.parked[0][0], y0: panels.parked[0][1], z0: top, gx: 0, gy: 0 }, [1, 0], (corners) => `<polygon class="u-pod" points="${pointList(corners)}"/>`);
+    if (slab !== undefined)
+        planes.push({ ...slab, id: "parked-top" });
+    panels.parked.forEach((a, i) => {
+        const b = panels.parked[(i + 1) % panels.parked.length];
+        const long = Math.hypot(b[0] - a[0], b[1] - a[1]);
+        if (long < 0.5)
+            return;
+        planes.push({ ...shy(wall(`parked-${i}`, "roof", a[0], a[1], b[0], b[1], z, top, `<rect class="u-pod" width="${n(long)}" height="${n(PANEL_THICK)}"/>`), c), fadeTo: 0.3 });
+    });
+    return planes;
+}
 /** The pod in the middle of a cable roof's opening, as a share of the opening's size, and how thick it is, in feet (ours: the article says the fabric gathers into a pod above the video board, not how large it is). */
 export const POD = { share: 0.24, thick: 9 };
 /**
  * What lies over the opening of a cable roof: the pod in the middle (a box hung at the crown's height) and, with the roof closed, the fabric between the pod and the opening's edge, drawn thin so that the seats
  * show through it. Open, only the pod is there: the fabric has gathered into it.
  */
-function cablePod(real, crown, edge, c, lift, steps, open) {
+function cablePod(z, edge, c, steps, open) {
     const planes = [];
-    const z = lift + real.edge + crown.rise;
     const pod = edge.map((p) => [c[0] + (p[0] - c[0]) * POD.share, c[1] + (p[1] - c[1]) * POD.share]);
     if (!open) {
         for (let k = 0; k < steps; k += 1) {

package/dist/venues-entry.d.ts

@@ -1,2 +1,2 @@
-export { VENUE_ATTRIBUTION, VENUE_IDS, VENUES, arenaOfVenue, bowlInside, planVenue, venueBowl, venueById, venueByWikidata, venueOrientation, venueRink, venuesIn } from "./venues.ts";
-export type { RealVenue, RealVenueData, VenueBasis, VenueDivision, VenueOrientation, VenueOsm, VenuePlan, VenueRoof } from "./venues.ts";
+export { VENUE_ATTRIBUTION, VENUE_CONFERENCES, VENUE_DIVISIONS, VENUE_IDS, VENUES, arenaOfVenue, bowlInside, conferenceOf, planVenue, venueBowl, venueById, venueByWikidata, venueOrientation, venueRink, venuesIn, venuesInConference } from "./venues.ts";
+export type { RealVenue, RealVenueData, VenueBasis, VenueConference, VenueDivision, VenueOrientation, VenueOsm, VenuePlan, VenueRoof } from "./venues.ts";

package/dist/venues-entry.js

@@ -1,2 +1,2 @@
 // The real venues of the NHL's arenas: the outline of each building and the way its rink lies (OpenStreetMap, ODbL 1.0) and a plausible bowl from the seats, tiers and roof the sources give (Wikidata, Wikipedia).
-export { VENUE_ATTRIBUTION, VENUE_IDS, VENUES, arenaOfVenue, bowlInside, planVenue, venueBowl, venueById, venueByWikidata, venueOrientation, venueRink, venuesIn } from "./venues.js";
+export { VENUE_ATTRIBUTION, VENUE_CONFERENCES, VENUE_DIVISIONS, VENUE_IDS, VENUES, arenaOfVenue, bowlInside, conferenceOf, planVenue, venueBowl, venueById, venueByWikidata, venueOrientation, venueRink, venuesIn, venuesInConference } from "./venues.js";

package/dist/venues.d.ts

@@ -6,8 +6,15 @@ export { VENUE_ATTRIBUTION };
 export type VenueBasis = "documented" | "plausible";
 /** The kinds of roof the venues have: `fixed` is a lid over the bowl, `saddle` a roof that rises at the two ends and falls at the two sides (the Scotiabank Saddledome's). */
 export type VenueRoof = "fixed" | "saddle";
-/** The NHL's divisions that have venues so far. */
-export type VenueDivision = "pacific";
+/** The NHL's divisions, in the order of the league's own listing: the Western Conference's two, then the Eastern's. A division none of whose arenas has a venue yet has no venues in `venuesIn`. */
+export declare const VENUE_DIVISIONS: readonly ["pacific", "central", "atlantic", "metropolitan"];
+export type VenueDivision = (typeof VENUE_DIVISIONS)[number];
+/** The NHL's two conferences, and the divisions of each. */
+export declare const VENUE_CONFERENCES: {
+    readonly western: readonly ["pacific", "central"];
+    readonly eastern: readonly ["atlantic", "metropolitan"];
+};
+export type VenueConference = keyof typeof VENUE_CONFERENCES;
 /** The facts of a venue: the seats and the number of seating levels and the kind of roof, each with what a source says. No text of an article is kept. */
 export interface RealVenueData {
     /** The key of the arena in `ARENAS`: `honda-center`. */
@@ -82,7 +89,7 @@ export interface VenueOrientation {
     basis: "mapped" | "building" | "none";
     north: number;
 }
-/** The venues by key: every arena of the Pacific division of the NHL, with its facts and its outline. */
+/** The venues by key: the arenas of the NHL's divisions that have been drawn, with their facts and their outlines. */
 export declare const VENUES: Readonly<Record<string, RealVenue>>;
 /** The keys of `VENUES`, in the order of the data. */
 export declare const VENUE_IDS: readonly string[];
@@ -92,6 +99,10 @@ export declare const venueById: (id: string | undefined) => RealVenue | undefine
 export declare const venueByWikidata: (wikidata: string | undefined) => RealVenue | undefined;
 /** The venues of a division of the NHL, in the order of the data. */
 export declare const venuesIn: (division: VenueDivision) => RealVenue[];
+/** The conference a division of the NHL is in. */
+export declare const conferenceOf: (division: VenueDivision) => VenueConference;
+/** The venues of a conference of the NHL, division by division, in the order of the data. */
+export declare const venuesInConference: (conference: VenueConference) => RealVenue[];
 /** The arena a venue is of. */
 export declare const arenaOfVenue: (venue: RealVenue) => Arena;
 /** How the rink lies in a venue's building (see `VenueOsm.axis`). */

package/dist/venues.data.js

@@ -71,4 +71,76 @@ export const VENUE_DATA = [
         "tiers": { "count": 2, "basis": "plausible", "read": "no source says how many seating levels there are: two bowls are drawn" },
         "roof": { "kind": "fixed", "basis": "plausible", "read": "an indoor arena: a fixed roof, as nothing says otherwise" },
     },
+    {
+        "id": "united-center",
+        "wikidata": "Q639975",
+        "division": "central",
+        "en": { "title": "United Center", "revision": 1380672233 },
+        "seats": { "hockey": 19717, "source": "wikipedia", "wikidata": 23500, "read": "the article's seating line for ice hockey, 19,717 (22,428 with standing room), which the infobox gives too; Wikidata's one capacity (23,500) is the concert one" },
+        "tiers": { "count": 2, "basis": "documented", "read": "the article tells of the 300 level seating bowl and of three levels of suites (down from 216 sky-boxes to 169 executive suites after 2009-10): a lower bowl and the 300 level, with the suites between as walks" },
+        "roof": { "kind": "fixed", "basis": "plausible", "read": "an indoor arena: a fixed roof, as nothing says otherwise; the article says the building is 140 feet tall, of concrete and steel" },
+    },
+    {
+        "id": "ball-arena",
+        "wikidata": "Q795470",
+        "division": "central",
+        "en": { "title": "Ball Arena", "revision": 1379560431 },
+        "seats": { "hockey": 17809, "source": "wikipedia", "wikidata": 19155, "read": "the infobox's figure for hockey (given with lacrosse), 17,809; Wikidata's capacity without a sport is 19,155 and its other (17,417) is for futsal" },
+        "tiers": { "count": 2, "basis": "plausible", "read": "no source says how many seating levels there are: two bowls are drawn" },
+        "roof": { "kind": "fixed", "basis": "plausible", "read": "an indoor arena: a fixed roof, as nothing says otherwise" },
+    },
+    {
+        "id": "american-airlines-center",
+        "wikidata": "Q463345",
+        "division": "central",
+        "en": { "title": "American Airlines Center", "revision": 1379833787 },
+        "seats": { "hockey": 18532, "source": "wikipedia", "wikidata": 19200, "read": "the infobox's figure for ice hockey, 18,532 (19,323 with standing room); Wikidata's one capacity (19,200) is the basketball one" },
+        "tiers": { "count": 2, "basis": "plausible", "read": "no source says how many seating levels there are: two bowls are drawn; the article speaks of retractable seating, which the bowl does not draw" },
+        "roof": { "kind": "fixed", "basis": "plausible", "read": "an indoor arena: a fixed roof, as nothing says otherwise; the article says the roof looks like a Quonset hut, a barrel vault, which the one kind of fixed roof does not draw" },
+    },
+    {
+        "id": "grand-casino-arena",
+        "wikidata": "Q1421388",
+        "division": "central",
+        "en": { "title": "Grand Casino Arena", "revision": 1379407082 },
+        "seats": { "hockey": 17954, "source": "wikidata", "wikidata": 17954, "read": "Wikidata's capacity for ice hockey from 2012 (P1083 with P641 ice hockey and P580 2012), the later of its two (18,064 from 2000); the article's lede and infobox give 17,954 too" },
+        "tiers": { "count": 3, "basis": "documented", "read": "the article says the arena has four spectator levels, one of suites and three for general seating: three seating bowls, with the suite level as a walk between them" },
+        "roof": { "kind": "fixed", "basis": "plausible", "read": "an indoor arena: a fixed roof, as nothing says otherwise" },
+    },
+    {
+        "id": "bridgestone-arena",
+        "wikidata": "Q302869",
+        "division": "central",
+        "en": { "title": "Bridgestone Arena", "revision": 1380457078 },
+        "seats": { "hockey": 17510, "source": "wikidata", "wikidata": 17510, "read": "Wikidata's capacity for ice hockey (P1083 with P641 ice hockey); the article's own line gives 17,159, 2.0 percent fewer" },
+        "tiers": { "count": 2, "basis": "plausible", "read": "no source says how many seating levels there are everywhere in the building: two bowls are drawn; the article speaks of upper-level seats and, at the south end only, of no mid-level seating and one level of suites" },
+        "roof": { "kind": "fixed", "basis": "plausible", "read": "an indoor arena: a fixed roof, as nothing says otherwise; the article speaks of two round roof support columns at the south end, which are not drawn" },
+    },
+    {
+        "id": "enterprise-center",
+        "wikidata": "Q1067700",
+        "division": "central",
+        "en": { "title": "Enterprise Center", "revision": 1372086380 },
+        "seats": { "hockey": 18096, "source": "wikipedia", "wikidata": 18400, "read": "the infobox's figure for ice hockey, 18,096, which the article's first sentence gives too; Wikidata's one capacity (18,400) is not for hockey" },
+        "tiers": { "count": 2, "basis": "documented", "read": "the article tells of the replacement of all upper-tier seats and of the lower-tier seats in the 2017 to 2019 renovation: two seating tiers" },
+        "roof": { "kind": "fixed", "basis": "plausible", "read": "an indoor arena: a fixed roof, as nothing says otherwise" },
+    },
+    {
+        "id": "delta-center",
+        "wikidata": "Q82294",
+        "division": "central",
+        "en": { "title": "Delta Center", "revision": 1379043310 },
+        "seats": { "hockey": 16020, "source": "wikipedia", "wikidata": 19911, "read": "the infobox's figure for ice hockey, 16,020, which the article's lede gives as the most for ice hockey; Wikidata's one capacity (19,911) is not for hockey" },
+        "tiers": { "count": 2, "basis": "plausible", "read": "no source says how many seating levels there are: two bowls are drawn; the article speaks of a lower bowl rebuilt in 2025 and of terrace-style ledges" },
+        "roof": { "kind": "fixed", "basis": "plausible", "read": "an indoor arena: a fixed roof, as nothing says otherwise" },
+    },
+    {
+        "id": "canada-life-centre",
+        "wikidata": "Q656928",
+        "division": "central",
+        "en": { "title": "Canada Life Centre", "revision": 1379717047 },
+        "seats": { "hockey": 15225, "source": "wikipedia", "wikidata": 15004, "read": "the article's seating capacity for hockey games, 15,225, which the infobox gives as the top of 8,812 to 15,225; Wikidata's one capacity (15,004) is older, before 278 premium seats were added to the upper level in 2015" },
+        "tiers": { "count": 2, "basis": "documented", "lowerShare": 0.579, "read": "the article says the lower bowl holds 8,812 and that premium seats were added to the upper level: two seating levels, the lower with 8,812 of the 15,225" },
+        "roof": { "kind": "fixed", "basis": "plausible", "read": "an indoor arena: a fixed roof, as nothing says otherwise" },
+    },
 ];

package/dist/venues.geo.d.ts

@@ -5,6 +5,28 @@ export type LonLat = readonly [number, number];
 export declare function metresFrom(origin: LonLat, ring: readonly LonLat[]): Pt[];
 /** The inverse of `metresFrom`: a point given as east and north metres from `origin`, in degrees. */
 export declare function lonLatFrom(origin: LonLat, [east, north]: Pt): LonLat;
+/** A point as OpenStreetMap's Overpass API returns it. */
+export interface OsmPoint {
+    lat: number;
+    lon: number;
+}
+/** An element as Overpass returns it with its geometry (`out geom`): a way's points, or a relation's members, each with theirs. */
+export interface OsmElement {
+    type: string;
+    id: number;
+    geometry?: readonly OsmPoint[];
+    members?: readonly {
+        type: string;
+        ref: number;
+        role: string;
+        geometry?: readonly OsmPoint[];
+    }[];
+}
+/**
+ * The closed outline an OpenStreetMap element is, as its points with the first repeated at the end, or `undefined`: a closed way is its own; a multipolygon relation is its outer members joined end to end into one
+ * ring (a building drawn in two or more ways); a relation with two outer rings or an outer way that does not close is not an outline (the caller says what rule it needs). Inner members are courtyards and are left out.
+ */
+export declare function outerRingOf(element: OsmElement): OsmPoint[] | undefined;
 /** The mean of a ring's longitudes and latitudes: a point to measure from. */
 export declare const middleOf: (ring: readonly LonLat[]) => LonLat;
 /** The area of a polygon, unsigned. */

package/dist/venues.geo.js

@@ -9,6 +9,34 @@ export function metresFrom(origin, ring) {
 export function lonLatFrom(origin, [east, north]) {
     return [origin[0] + east / (RAD * EARTH * Math.cos(origin[1] * RAD)), origin[1] + north / (RAD * EARTH)];
 }
+const same = (a, b) => a.lat === b.lat && a.lon === b.lon;
+/**
+ * The closed outline an OpenStreetMap element is, as its points with the first repeated at the end, or `undefined`: a closed way is its own; a multipolygon relation is its outer members joined end to end into one
+ * ring (a building drawn in two or more ways); a relation with two outer rings or an outer way that does not close is not an outline (the caller says what rule it needs). Inner members are courtyards and are left out.
+ */
+export function outerRingOf(element) {
+    if (element.type === "way") {
+        const g = element.geometry;
+        return g !== undefined && g.length > 3 && same(g[0], g[g.length - 1]) ? [...g] : undefined;
+    }
+    if (element.type !== "relation" || element.members === undefined)
+        return undefined;
+    const parts = element.members.filter((m) => m.type === "way" && m.role === "outer" && m.geometry !== undefined && m.geometry.length > 1).map((m) => [...m.geometry]);
+    if (parts.length === 0)
+        return undefined;
+    const ring = parts.shift();
+    while (!same(ring[0], ring[ring.length - 1]) && parts.length > 0) {
+        const tail = ring[ring.length - 1];
+        const next = parts.findIndex((part) => same(part[0], tail) || same(part[part.length - 1], tail));
+        if (next < 0)
+            return undefined;
+        const [part] = parts.splice(next, 1);
+        if (!same(part[0], tail))
+            part.reverse();
+        ring.push(...part.slice(1));
+    }
+    return parts.length === 0 && ring.length > 3 && same(ring[0], ring[ring.length - 1]) ? ring : undefined;
+}
 /** The mean of a ring's longitudes and latitudes: a point to measure from. */
 export const middleOf = (ring) => [ring.reduce((s, p) => s + p[0], 0) / ring.length, ring.reduce((s, p) => s + p[1], 0) / ring.length];
 /** The area of a polygon, unsigned. */

package/dist/venues.js

@@ -9,7 +9,11 @@ import { boxOf, edgeDistance, inside, metresFrom, middleOf, northOn, turnedTo }
 import { VENUE_DATA } from "./venues.data.js";
 import { VENUE_ATTRIBUTION, VENUE_OSM } from "./venues.osm.data.js";
 export { VENUE_ATTRIBUTION };
-/** The venues by key: every arena of the Pacific division of the NHL, with its facts and its outline. */
+/** The NHL's divisions, in the order of the league's own listing: the Western Conference's two, then the Eastern's. A division none of whose arenas has a venue yet has no venues in `venuesIn`. */
+export const VENUE_DIVISIONS = ["pacific", "central", "atlantic", "metropolitan"];
+/** The NHL's two conferences, and the divisions of each. */
+export const VENUE_CONFERENCES = { western: ["pacific", "central"], eastern: ["atlantic", "metropolitan"] };
+/** The venues by key: the arenas of the NHL's divisions that have been drawn, with their facts and their outlines. */
 export const VENUES = Object.freeze(Object.fromEntries(VENUE_DATA.map((data) => [data.id, Object.freeze({ ...data, osm: VENUE_OSM[data.id] })])));
 /** The keys of `VENUES`, in the order of the data. */
 export const VENUE_IDS = Object.freeze(VENUE_DATA.map((data) => data.id));
@@ -19,6 +23,10 @@ export const venueById = (id) => (id !== undefined && Object.prototype.hasOwnPro
 export const venueByWikidata = (wikidata) => Object.values(VENUES).find((venue) => venue.wikidata === wikidata);
 /** The venues of a division of the NHL, in the order of the data. */
 export const venuesIn = (division) => Object.values(VENUES).filter((venue) => venue.division === division);
+/** The conference a division of the NHL is in. */
+export const conferenceOf = (division) => VENUE_CONFERENCES.western.includes(division) ? "western" : "eastern";
+/** The venues of a conference of the NHL, division by division, in the order of the data. */
+export const venuesInConference = (conference) => VENUE_CONFERENCES[conference].flatMap((division) => venuesIn(division));
 /** The arena a venue is of. */
 export const arenaOfVenue = (venue) => {
     const arena = arenaById(venue.id);