@johnmorrisdotca/kyogijo-stadiums 0.24.0 → 0.26.0

package/dist/strings.d.ts

@@ -504,6 +504,12 @@ export interface KyogijoWords {
         arenaSize: string;
         /** An arena whose rink is said to have been shorter than the NHL's, with no size given: {arena}. */
         arenaUnknown: string;
+        /** The stands of an arena's real venue: {seats} seats in {tiers} tiers, fitted inside the outline of {arena}'s building from OpenStreetMap. */
+        real: string;
+        /** How the rink lies in it: along the building's long axis (an inference), as OpenStreetMap maps the ice, or not known. */
+        realBuilding: string;
+        realMapped: string;
+        realNone: string;
         /** A game decided on penalties: {name}, and the shoot-out score {a}-{b}, winner first. */
         wonPens: string;
         /** The shoot-out, as it is written beside a status: {a} and {b}, in the order of the sides on the drawing. */

package/dist/strings.js

@@ -199,7 +199,7 @@ export const KYOGIJO_STRINGS = {
             },
         },
         scoreTitle: "{away} {awayScore}, {home} {homeScore}",
-        said: { home: "home", away: "away", won: "{name} won.", tied: "The game is level.", park: "The outfield fence follows the figures published for {park}.", officially: "Its official name is {name}.", ground: "The pitch follows the size published for {ground}.", groundDefault: "No pitch size is published for {ground}, so the pitch has the international size of 105 by 68 metres.", arenaRink: "{arena}, hockey rink", arenaCourt: "{arena}, basketball court", arenaRinkAbout: "an ice hockey rink, {length} by {width} feet ({lengthM} by {widthM} metres) with rounded corners, with its red and blue lines, face-off circles, creases and goal nets", arenaCourtAbout: "a basketball court, {length} by {width} feet ({lengthM} by {widthM} metres), with its keys, three-point lines, free-throw circles and the centre circle", arenaSize: "The size is the one published for {arena}.", arenaUnknown: "The article says the rink of {arena} was shorter than the NHL's but gives no size, so the NHL's is drawn.", era: "The markings are those of the {season} season.", hammer: "{name} has the hammer.", ends: "By end, {name}: {list}.", total: "Total", wonPens: "{name} won {a}-{b} on penalties.", pens: "{a}-{b} pens", on: "Drawn as", sep: ", ", stop: ".", colon: ": ", gap: " " },
+        said: { home: "home", away: "away", won: "{name} won.", tied: "The game is level.", park: "The outfield fence follows the figures published for {park}.", officially: "Its official name is {name}.", ground: "The pitch follows the size published for {ground}.", groundDefault: "No pitch size is published for {ground}, so the pitch has the international size of 105 by 68 metres.", arenaRink: "{arena}, hockey rink", arenaCourt: "{arena}, basketball court", arenaRinkAbout: "an ice hockey rink, {length} by {width} feet ({lengthM} by {widthM} metres) with rounded corners, with its red and blue lines, face-off circles, creases and goal nets", arenaCourtAbout: "a basketball court, {length} by {width} feet ({lengthM} by {widthM} metres), with its keys, three-point lines, free-throw circles and the centre circle", arenaSize: "The size is the one published for {arena}.", arenaUnknown: "The article says the rink of {arena} was shorter than the NHL's but gives no size, so the NHL's is drawn.", real: "The stands are a plausible bowl of {seats} seats in {tiers} tiers, fitted inside the outline of the building of {arena} from OpenStreetMap ((c) OpenStreetMap contributors); it is not the arena's plan.", realBuilding: "The rink lies along the building's long axis, which is an inference, and the arrow points north.", realMapped: "The rink lies as OpenStreetMap maps the ice, and the arrow points north.", realNone: "The rink's orientation is not known, so it is drawn east-west with north at the top.", era: "The markings are those of the {season} season.", hammer: "{name} has the hammer.", ends: "By end, {name}: {list}.", total: "Total", wonPens: "{name} won {a}-{b} on penalties.", pens: "{a}-{b} pens", on: "Drawn as", sep: ", ", stop: ".", colon: ": ", gap: " " },
         budo: {
             sides: { north: "north", south: "south", east: "east", west: "west" },
             judo: "a judo contest area of {contest} by {contest} metres in a safety area {safety} metres wide, laid with tatami of {tatami}",
@@ -758,7 +758,7 @@ export const KYOGIJO_STRINGS = {
             },
         },
         scoreTitle: "{away} {awayScore}、{home} {homeScore}",
-        said: { home: "ホーム", away: "アウェイ", won: "{name}の勝ちです。", tied: "同点です。", park: "外野フェンスは、{park}の公表されている距離をもとに描かれています。", officially: "正式名称は{name}です。", ground: "ピッチは、{ground}の公表されている広さをもとに描かれています。", groundDefault: "{ground}のピッチの広さは公表されていないため、国際標準の105×68mで描かれています。", arenaRink: "{arena}のアイスホッケーリンク", arenaCourt: "{arena}のバスケットボールコート", arenaRinkAbout: "アイスホッケーのリンク。{length}フィート（約{lengthM}m）×{width}フィート（約{widthM}m）で角が丸く、レッドライン、ブルーライン、フェイスオフサークル、クリース、ゴールがあります", arenaCourtAbout: "バスケットボールのコート。{length}フィート（約{lengthM}m）×{width}フィート（約{widthM}m）で、ペイントエリア、スリーポイントライン、フリースローサークル、センターサークルがあります", arenaSize: "広さは、{arena}の公表されている数値をもとに描かれています。", arenaUnknown: "{arena}のリンクはNHLの規格より短かったとされていますが、広さが示されていないため、NHLの規格で描かれています。", era: "ラインやマークは{season}シーズンのものです。", hammer: "{name}がハンマー（最後の1投）を持っています。", ends: "{name}のエンドごとの得点：{list}。", total: "合計", wonPens: "{name}がPK戦を{a}-{b}で制しました。", pens: "PK戦 {a}-{b}", on: "図の内容", sep: "、", stop: "。", colon: "：", gap: "" },
+        said: { home: "ホーム", away: "アウェイ", won: "{name}の勝ちです。", tied: "同点です。", park: "外野フェンスは、{park}の公表されている距離をもとに描かれています。", officially: "正式名称は{name}です。", ground: "ピッチは、{ground}の公表されている広さをもとに描かれています。", groundDefault: "{ground}のピッチの広さは公表されていないため、国際標準の105×68mで描かれています。", arenaRink: "{arena}のアイスホッケーリンク", arenaCourt: "{arena}のバスケットボールコート", arenaRinkAbout: "アイスホッケーのリンク。{length}フィート（約{lengthM}m）×{width}フィート（約{widthM}m）で角が丸く、レッドライン、ブルーライン、フェイスオフサークル、クリース、ゴールがあります", arenaCourtAbout: "バスケットボールのコート。{length}フィート（約{lengthM}m）×{width}フィート（約{widthM}m）で、ペイントエリア、スリーポイントライン、フリースローサークル、センターサークルがあります", arenaSize: "広さは、{arena}の公表されている数値をもとに描かれています。", arenaUnknown: "{arena}のリンクはNHLの規格より短かったとされていますが、広さが示されていないため、NHLの規格で描かれています。", real: "スタンドは、OpenStreetMapの建物の輪郭（(c) OpenStreetMap contributors）の内側に収まるように、{arena}の{seats}席・{tiers}層を推定して描いたもので、アリーナの設計図ではありません。", realBuilding: "リンクは建物の長い軸に沿って置いており（推定）、矢印は北を指します。", realMapped: "リンクの向きはOpenStreetMapに記録された氷面のとおりで、矢印は北を指します。", realNone: "リンクの向きは分かっていないため、東西に置き、北を上にしています。", era: "ラインやマークは{season}シーズンのものです。", hammer: "{name}がハンマー（最後の1投）を持っています。", ends: "{name}のエンドごとの得点：{list}。", total: "合計", wonPens: "{name}がPK戦を{a}-{b}で制しました。", pens: "PK戦 {a}-{b}", on: "図の内容", sep: "、", stop: "。", colon: "：", gap: "" },
         budo: {
             sides: { north: "北", south: "南", east: "東", west: "西" },
             judo: "柔道の試合場。試合場内は{contest}m四方、幅{safety}mの安全地帯があり、{tatami}の畳を敷いています",

package/dist/turn.model.js

@@ -89,7 +89,9 @@ export function buildTurn(options, settings = {}) {
     const reach = uprights.reach;
     const margin = reach === undefined ? undefined : convertLength(reach, "ft", lengthUnit(asked));
     const own = asked.margin;
-    const base = reach !== undefined && crowdOpt !== undefined && crowdOpt !== false ? { ...asked, crowd: undefined, margin: Math.max(margin ?? 0, typeof own === "number" && Number.isFinite(own) ? own : 0) } : asked;
+    // (A real venue's building stays on the floor, with the arrow that says where north is: the crowd drawn without its seats.)
+    const keep = resolveCrowd(crowdOpt)?.real === true ? { real: true, stands: false } : undefined;
+    const base = reach !== undefined && crowdOpt !== undefined && crowdOpt !== false ? { ...asked, crowd: keep, margin: Math.max(margin ?? 0, typeof own === "number" && Number.isFinite(own) ? own : 0) } : asked;
     const o = boarded ? { ...base, plate: false, size: asked.size === "compact" ? "full" : asked.size } : base;
     const floor = settings.floor === undefined ? drawKyogijo(o) : settings.floor(o);
     const found = VIEWBOX.exec(floor);

package/dist/turn.style.js

@@ -66,6 +66,7 @@ export const KYOGIJO_TURN_STYLE = `
 .ky-turn .u-th{fill:var(--ky-cr-home)}
 .ky-turn .u-conc{fill:var(--ky-cr-conc)}
 .ky-turn .u-fascia{fill:var(--ky-up-fascia)}
+.ky-turn .u-shell{fill:var(--ky-up-fascia);stroke:var(--ky-up-roofline);stroke-width:.6}
 .ky-turn .u-roof{fill:var(--ky-up-roof);stroke:var(--ky-up-roofline);stroke-width:.8;stroke-linejoin:round}
 .ky-turn .ky-up-seats svg{opacity:var(--ky-cr-dim)}
 .ky-turn .ky-cr-seat{fill:none;stroke:var(--ky-cr-empty);stroke-width:1.3;stroke-opacity:.65}

package/dist/types.d.ts

@@ -284,6 +284,14 @@ export interface CrowdOptions {
      * ballpark's outfield with a gap at the batter's eye) or `grandstand` (a ballpark's infield stands only). Each sport has its usual one.
      */
     shape?: CrowdShape;
+    /**
+     * The stands of the arena's real venue, for an NHL `arena` the package has one of (`VENUES`, `@johnmorrisdotca/kyogijo-stadiums/venues`): the outline of its building from OpenStreetMap, the rink lying along
+     * the building as it does in the world (a small arrow says where north is), and a bowl of the number of tiers and the seats the sources give, fitted inside the building, under its kind of roof. An arena with no venue
+     * is drawn with the usual stands. Off by default. The drawing needs the credit `VENUE_ATTRIBUTION`. See `docs/venues.md`.
+     */
+    real?: boolean;
+    /** `false` draws no seats: of a real venue (`real`) only its building and the arrow that says where north is, which is what the floor of the 3D view needs under the stands it raises. On by default. */
+    stands?: boolean;
     /** The end of a `horseshoe` that is open: `right` (the usual) or `left`. */
     open?: "left" | "right";
     /**

package/dist/venue.js

@@ -6,7 +6,8 @@ import { densityOf, resolveCrowd } from "./crowd.js";
 import { patterns } from "./crowd.draw.js";
 import { crowdStands } from "./draw.js";
 import { groundById } from "./grounds.js";
-import { clipAround, clipConvex, clipSegment, areaOf, pointList, raked, slopeOf, stripsOf, tidy } from "./venue.geom.js";
+import { ARC_STEPS, clipAround, clipConvex, clipSegment, areaOf, pointList, raked, slopeOf, stripsOf, tidy } from "./venue.geom.js";
+import { realBuilding } from "./venue.real.js";
 import { n, shy, wall } from "./turn.kit.js";
 export const NO_VENUE = { items: [], defs: "", reach: 0 };
 /** The sports played under a roof: their stands have a lid and not a canopy. */
@@ -45,7 +46,7 @@ export function standsVenueOf(stands, crowd, o, v, lift) {
     const density = densityOf(crowd, stands.seats, groundById(o.ground)?.capacity);
     const tifo = { home: stands.sectors.some((s) => s.kind === "tifo-home"), away: stands.sectors.some((s) => s.kind === "tifo-away") };
     const pid = `${v.id}-v`;
-    const defs = fine ? patterns(pid, crowd, density, tifo.home || tifo.away ? tifo : undefined, false, true) : "";
+    const defs = fine ? patterns(pid, crowd, density, tifo.home || tifo.away ? tifo : undefined, stands.real !== undefined, true) : "";
     const centre = [stands.box.x + stands.box.w / 2, stands.box.y + stands.box.h / 2];
     const covers = stands.covers;
     const inCover = (p) => covers.some(([x0, y0, x1, y1]) => p[0] >= x0 && p[0] <= x1 && p[1] >= y0 && p[1] <= y1);
@@ -148,8 +149,10 @@ export function standsVenueOf(stands, crowd, o, v, lift) {
         items.push({ id: "stands", kind: "stands", at: centre, height: topOf(seatPlanes), planes: seatPlanes });
     if (wallSeats.length > 0)
         items.push({ id: "wall-seats", kind: "wall-seats", at: centre, height: topOf(wallSeats), planes: wallSeats });
-    // The roof: a canopy over the back of the top tier, or a lid over it in a hall.
-    const top = v.roof === true && crowd.roof ? topRing(stands) : undefined;
+    // The roof: a canopy over the back of the top tier, or a lid over it in a hall. A real venue has its own: the walls of its building and a roof of its kind over them.
+    if (stands.real !== undefined && v.roof === true)
+        items.push(...realBuilding(stands.real, topRing(stands), centre, lift, ARC_STEPS[cut].oval * 2));
+    const top = v.roof === true && crowd.roof && stands.real === undefined ? topRing(stands) : undefined;
     if (top !== undefined) {
         const lid = INDOOR.includes(String(o.sport));
         const reach = lid ? 1 : ROOF.canopyReach;

package/dist/venue.real.d.ts

@@ -0,0 +1,16 @@
+import { type Pt, type RealShell, type StandRing } from "./crowd.ts";
+import { type Upright } from "./turn.kit.ts";
+/** How far a lid rises from its edge towards the middle, and how far a saddle's high ends stand over its low sides, in feet (ours: the sources give a roof's kind, not its height). */
+export declare const LID_RISE = 22;
+export declare const SADDLE_RISE = 30;
+/** The saddle's share of its rise at a point (0 at the middle of a side, 1 at the middle of an end): half a saddle's way from one to the other, as a hyperbolic paraboloid (u squared less v squared) lies over the building's box. */
+export declare function saddleAt(real: Pick<RealShell, "footprint">, [x, y]: Pt): number;
+/** The height of the roof over a point of the building's edge, above the surface, in feet. */
+export declare const roofAt: (real: RealShell, p: Pt) => number;
+/**
+ * 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`
+ * 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 declare function realBuilding(real: RealShell, top: StandRing | undefined, centre: readonly [number, number], lift: number, steps: number): Items;
+type Items = Upright[];
+export {};

package/dist/venue.real.js

@@ -0,0 +1,103 @@
+// 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 or a saddle that rises at the two ends and falls at the two
+// sides. Both 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";
+import { pointList, raked } from "./venue.geom.js";
+/** How far a lid rises from its edge towards the middle, and how far a saddle's high ends stand over its low sides, in feet (ours: the sources give a roof's kind, not its height). */
+export const LID_RISE = 22;
+export const SADDLE_RISE = 30;
+/** The saddle's share of its rise at a point (0 at the middle of a side, 1 at the middle of an end): half a saddle's way from one to the other, as a hyperbolic paraboloid (u squared less v squared) lies over the building's box. */
+export function saddleAt(real, [x, y]) {
+    const xs = real.footprint.map((p) => p[0]);
+    const ys = real.footprint.map((p) => p[1]);
+    const [cx, cy] = [(Math.min(...xs) + Math.max(...xs)) / 2, (Math.min(...ys) + Math.max(...ys)) / 2];
+    const [hx, hy] = [(Math.max(...xs) - Math.min(...xs)) / 2, (Math.max(...ys) - Math.min(...ys)) / 2];
+    const s = ((x - cx) / hx) ** 2 - ((y - cy) / hy) ** 2;
+    return (1 + Math.max(-1, Math.min(1, s))) / 2;
+}
+/** The height of the roof over a point of the building's edge, above the surface, in feet. */
+export const roofAt = (real, p) => real.edge + (real.roof === "saddle" ? SADDLE_RISE * saddleAt(real, p) : 0);
+/** The point where a ray from `from` first meets a polygon, or `undefined`. */
+function firstHit(poly, from, angle) {
+    const [dx, dy] = [Math.cos(angle), Math.sin(angle)];
+    let best;
+    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 && (best === undefined || t < best.t))
+            best = { t, p: [from[0] + dx * t, from[1] + dy * t] };
+    });
+    return best?.p;
+}
+/** The plane a quad of points with heights lies nearest to, as a slope: least squares through its corners. */
+function slopeThrough(points) {
+    const m = points.length;
+    const [mx, my, mz] = [points.reduce((s, p) => s + p[0], 0) / m, points.reduce((s, p) => s + p[1], 0) / m, points.reduce((s, p) => s + p[2], 0) / m];
+    let [sxx, sxy, syy, sxz, syz] = [0, 0, 0, 0, 0];
+    for (const [x, y, z] of points) {
+        sxx += (x - mx) ** 2;
+        sxy += (x - mx) * (y - my);
+        syy += (y - my) ** 2;
+        sxz += (x - mx) * (z - mz);
+        syz += (y - my) * (z - mz);
+    }
+    const det = sxx * syy - sxy * sxy;
+    const [gx, gy] = Math.abs(det) < 1e-9 ? [0, 0] : [(sxz * syy - syz * sxy) / det, (syz * sxx - sxz * sxy) / det];
+    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`
+ * 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) {
+    const items = [];
+    const c = [centre[0], centre[1]];
+    const rim = Array.from({ length: steps }, (_, k) => {
+        const angle = (2 * Math.PI * k) / steps;
+        const cap = rayAt(real.hall, c[0], c[1], angle);
+        const out = firstHit(real.footprint, c, angle);
+        return out !== undefined && Math.hypot(out[0] - c[0], out[1] - c[1]) < Math.hypot(cap[0] - c[0], cap[1] - c[1]) ? out : cap;
+    });
+    const planes = [];
+    rim.forEach((a, i) => {
+        const b = rim[(i + 1) % steps];
+        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]);
+        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)
+        items.push({ id: "shell", kind: "walls", at: centre, height: Math.max(...planes.map((p) => p.o[2])), planes });
+    if (top?.hole == null)
+        return items;
+    const roof = [];
+    const hole = top.hole;
+    const inner = rim.map((_, k) => rayAt(hole, c[0], c[1], (2 * Math.PI * k) / steps));
+    const rise = real.roof === "saddle" ? 0 : LID_RISE;
+    const zOf = (p, inward) => lift + roofAt(real, p) + (inward ? rise : 0);
+    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 quad = [ai, bi, b, a];
+        const heights = [zOf(ai, true), zOf(bi, true), zOf(b, false), zOf(a, false)];
+        const slope = slopeThrough(quad.map((p, i) => [p[0], p[1], heights[i]]));
+        const [ex, ey] = [b[0] - a[0], b[1] - a[1]];
+        const el = Math.hypot(ex, ey);
+        if (el < 1e-6)
+            continue;
+        const mid = [(a[0] + b[0] + ai[0] + bi[0]) / 4, (a[1] + b[1] + ai[1] + bi[1]) / 4];
+        const away = Math.hypot(mid[0] - c[0], mid[1] - c[1]);
+        const piece = raked(`roof-${k}`, "roof", quad, slope, [ex / el, ey / el], (corners) => `<polygon class="u-roof" points="${pointList(corners)}"/>`);
+        if (piece !== undefined)
+            roof.push({ ...piece, shy: [(mid[0] - c[0]) / away, (mid[1] - c[1]) / away] });
+    }
+    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 });
+    return items;
+}

package/dist/venues-entry.d.ts

@@ -0,0 +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";

package/dist/venues-entry.js

@@ -0,0 +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";

package/dist/venues.d.ts

@@ -0,0 +1,153 @@
+import { type Arena, type ArenaSource } from "./arenas.ts";
+import { type Box, type Pt, type RealBowl } from "./crowd.ts";
+import { VENUE_ATTRIBUTION } from "./venues.osm.data.ts";
+export { VENUE_ATTRIBUTION };
+/** How a fact is known: `documented` is what a source cited with it says; `plausible` is ours, for a bowl no source describes. */
+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 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`. */
+    id: string;
+    /** The Wikidata item of the arena. */
+    wikidata: string;
+    division: VenueDivision;
+    /** The English Wikipedia article the facts that are not Wikidata's were read from, at a revision. */
+    en: ArenaSource;
+    seats: {
+        /** The seats for ice hockey: Wikidata's where its item gives a figure for ice hockey (`wikidata`), else the article's (`wikipedia`). */
+        hockey: number;
+        source: "wikidata" | "wikipedia";
+        /** Wikidata's own capacity (P1083), kept beside it: it is often for another event, or an older year. */
+        wikidata: number;
+        /** What was read, in a few words of ours. */
+        read: string;
+    };
+    tiers: {
+        /** The seating levels (bowls), with the suites and the clubs that lie between them counted as walks, not tiers. */
+        count: 1 | 2 | 3;
+        basis: VenueBasis;
+        /** The share of the seats that are in the lowest tier, where a source gives it. */
+        lowerShare?: number;
+        read: string;
+    };
+    roof: {
+        kind: VenueRoof;
+        basis: VenueBasis;
+        read: string;
+    };
+}
+/** What OpenStreetMap gave of a venue: ODbL 1.0 data, "(c) OpenStreetMap contributors". */
+export interface VenueOsm {
+    /** The element the outline is: `way/120623151`. */
+    source: string;
+    /** The day it was read and the time of the OpenStreetMap data the answer was made from. */
+    read: string;
+    base: string;
+    licence: "ODbL-1.0";
+    attribution: string;
+    /** The building's height in metres, where OpenStreetMap maps one. */
+    height?: number;
+    /** The building's outline as `[longitude, latitude]`, not repeating its first point. */
+    ring: [number, number][];
+    /** The ice, where OpenStreetMap maps it inside the building: the element and its outline. */
+    ice?: {
+        source: string;
+        ring: [number, number][];
+    };
+    /**
+     * How the rink lies, worked out when the data was made: the heading of its long side (degrees clockwise from north, 0 to under 180), how that is known (`mapped`: from the ice OpenStreetMap maps; `building`: from the long
+     * axis of the building's main hall, the largest rectangle that fits its outline, which a rink usually follows, an inference; `none`: the building has no direction, 90 is stood in), how much of a direction the building has
+     * (`strength`, 1 for a round one) and how much longer than wide its main hall is (`elongation`), and the middle of the ice or of the main hall as `[longitude, latitude]`.
+     */
+    axis: {
+        heading: number;
+        basis: "mapped" | "building" | "none";
+        strength: number;
+        elongation: number;
+        centre: [number, number];
+    };
+}
+/** A venue: its facts and what OpenStreetMap gave. */
+export interface RealVenue extends RealVenueData {
+    osm: VenueOsm;
+}
+/** How the rink lies in the building: its long side's heading (degrees clockwise from north, 0 to under 180), how that is known, and the way north points on the page (degrees clockwise from the top). */
+export interface VenueOrientation {
+    heading: number;
+    /** `mapped`: from the ice OpenStreetMap maps in the building. `building`: from the building's long axis, which a rink usually follows (an inference). `none`: the building is near round, nothing is known, the plan has north at the top. */
+    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. */
+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[];
+/** The venue of an arena (by its key in `ARENAS`), or `undefined`. */
+export declare const venueById: (id: string | undefined) => RealVenue | undefined;
+/** The venue whose arena is the Wikidata item `Q774138`, or `undefined`. */
+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 arena a venue is of. */
+export declare const arenaOfVenue: (venue: RealVenue) => Arena;
+/** How the rink lies in a venue's building (see `VenueOsm.axis`). */
+export declare const venueOrientation: (venue: RealVenue) => VenueOrientation;
+/** The rink's box as the drawing has it: the arena's own where its sources publish a size, else the NHL's. */
+export declare function venueRink(venue: RealVenue): Box;
+/** The floor a seat takes in plan, in square feet (ours): a bowl of today's arenas is steeper than the usual drawing's, whose seat is 2 by 2.3 feet (4.6), so that a seat takes less of the floor's area. Tried in turn: a building
+ * with room for the seats at the first has the first; one with less has a steeper bowl, to the last, which is the least a seat takes. */
+export declare const SEAT_AREAS: readonly number[];
+/** How far the bowl's outer edge keeps from the building's wall, in feet (ours: the wall and the walk round the bowl). */
+export declare const WALL = 10;
+/** How far the hall's wall stands beyond the bowl's outer edge, in feet, where the building's outline allows: the concourse and the wall, ours. */
+export declare const HALL = 30;
+/** The walk between two tiers, in feet (ours: a suite level or a club between two bowls). */
+export declare const GAP = 10;
+/** The height of the first row above the ice, in feet, the rise of a tier's rows by the number of tiers (what the lowest, a middle and the upper bowl rise, at most), the rise of the walk between two tiers (a suite level), and the steepest a bowl is raked, in degrees (ours: no source gives them). */
+export declare const FIRST_HEIGHT = 4;
+export declare const RISES: Readonly<Record<1 | 2 | 3, readonly number[]>>;
+export declare const WALK_RISE = 16;
+export declare const MAX_RAKE = 36;
+/** The height a roof's edge stands over the top row, at the least, in feet. */
+export declare const CLEARANCE = 22;
+/** The plan of a venue: its building in the drawing's frame, the bowl fitted inside, and how it lies. */
+export interface VenuePlan {
+    venue: RealVenue;
+    orientation: VenueOrientation;
+    /** The rink, in the drawing's frame. */
+    box: Box;
+    /** The building's outline in feet, in the drawing's frame (the rink along x, in the middle of the building's box). */
+    footprint: Pt[];
+    /** The stands for `layoutOf`: tiers, first row, ground, and the building and roof. */
+    bowl: RealBowl;
+    /** The seats the bowl's tiers hold, by tier, and in all: equal to the venue's seats where the building has room (`fit` is `fits`) and fewer where it has not (`tight`). */
+    seats: {
+        tier: string;
+        seats: number;
+    }[];
+    total: number;
+    /** The floor a seat takes in the plan, in square feet (one of `SEAT_AREAS`). */
+    seatArea: number;
+    fit: "fits" | "tight";
+}
+/**
+ * The plan of a venue's bowl: the building's outline turned so that the rink lies along x, a first row round the rink as an NHL arena has it, the largest bowl-shaped outline that fits the building round the middle of its main
+ * hall, and between the two the tiers, the outer edge of each placed so that its band holds the share of the venue's seats the sources give it (at `SEAT_AREAS` square feet a seat), with a walk between the tiers. The
+ * bowl is as long and wide as the building lets it be and as round at the corners as a bowl is; the rest is the building's.
+ * @example
+ * ```ts
+ * import { planVenue, venueById } from "@johnmorrisdotca/kyogijo-stadiums/venues";
+ * const plan = planVenue(venueById("honda-center")!);
+ * console.log(plan.orientation.basis, plan.seats.map((t) => t.tier).join(" "), plan.total);
+ * // building lower upper 17174
+ * ```
+ */
+export declare function planVenue(venue: RealVenue, rink?: Box): VenuePlan;
+/** The stands of a venue for `layoutOf` and the 3D view, round a rink: `planVenue`'s bowl. */
+export declare const venueBowl: (venue: RealVenue, rink?: Box) => RealBowl;
+/** Whether the bowl lies inside the building: every corner of every tier's outer edge is inside the footprint. */
+export declare function bowlInside(plan: VenuePlan): boolean;

package/dist/venues.data.d.ts

@@ -0,0 +1,2 @@
+import type { RealVenueData } from "./venues.ts";
+export declare const VENUE_DATA: RealVenueData[];

package/dist/venues.data.js

@@ -0,0 +1,74 @@
+export const VENUE_DATA = [
+    {
+        "id": "honda-center",
+        "wikidata": "Q774138",
+        "division": "pacific",
+        "en": { "title": "Honda Center", "revision": 1380000927 },
+        "seats": { "hockey": 17174, "source": "wikipedia", "wikidata": 17174, "read": "the article's seating line for the Ducks, 17,174, which the infobox gives for ice hockey too; Wikidata's one capacity (P1083) is the same" },
+        "tiers": { "count": 2, "basis": "plausible", "read": "no source says how many seating levels there are: two bowls (a lower and an upper) are drawn, the usual for an arena of 17,000 seats; the article speaks of two full levels of ribbon displays, one on each bowl's fascia, which agrees" },
+        "roof": { "kind": "fixed", "basis": "plausible", "read": "an indoor arena: a fixed roof, as nothing says otherwise" },
+    },
+    {
+        "id": "scotiabank-saddledome",
+        "wikidata": "Q1140083",
+        "division": "pacific",
+        "en": { "title": "Scotiabank Saddledome", "revision": 1377341466 },
+        "seats": { "hockey": 19289, "source": "wikipedia", "wikidata": 16605, "read": "the infobox's present figure for hockey (19,289, from 1995), which the article's amenities line gives too; Wikidata's 16,605 is the 1983 figure and the first the infobox lists" },
+        "tiers": { "count": 2, "basis": "documented", "read": "the article speaks of the lower bowl, a second level and upper loges above it: two seating levels with suites at the top of the lower bowl" },
+        "roof": { "kind": "saddle", "basis": "documented", "read": "the article says the roof is a reverse hyperbolic paraboloid, shaped like a horse saddle; which way the saddle lies over the ice is not given: it is drawn high at the two ends" },
+    },
+    {
+        "id": "rogers-place",
+        "wikidata": "Q5339036",
+        "division": "pacific",
+        "en": { "title": "Rogers Place", "revision": 1380110483 },
+        "seats": { "hockey": 18641, "source": "wikidata", "wikidata": 18641, "read": "Wikidata's capacity for ice hockey (P1083 with the sport P641 ice hockey); the article's own line gives 18,347 for a hockey arena, 1.6 percent fewer, and OpenStreetMap has 18,641" },
+        "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": "crypto-com-arena",
+        "wikidata": "Q186080",
+        "division": "pacific",
+        "en": { "title": "Crypto.com Arena", "revision": 1380458624 },
+        "seats": { "hockey": 18145, "source": "wikipedia", "wikidata": 19060, "read": "the article's figure for ice hockey, 18,145, which the infobox gives too; Wikidata's one capacity (19,060) is not for hockey" },
+        "tiers": { "count": 2, "basis": "documented", "lowerShare": 0.667, "read": "the article says two thirds of the seating, with the club seats, is in the lower bowl, and that three levels of suites lie between the lower and upper bowls" },
+        "roof": { "kind": "fixed", "basis": "plausible", "read": "an indoor arena: a fixed roof, as nothing says otherwise" },
+    },
+    {
+        "id": "sap-center",
+        "wikidata": "Q261863",
+        "division": "pacific",
+        "en": { "title": "SAP Center", "revision": 1380804230 },
+        "seats": { "hockey": 17435, "source": "wikipedia", "wikidata": 19190, "read": "the article says the hockey capacity changed from 17,562 to 17,435 when the new premium seating was finished (2023); Wikidata's one capacity (19,190) is the concert one" },
+        "tiers": { "count": 2, "basis": "plausible", "read": "no source says how many seating levels there are: two bowls are drawn; the article speaks of club levels and a penthouse, which are not seating bowls" },
+        "roof": { "kind": "fixed", "basis": "plausible", "read": "an indoor arena: a fixed roof, as nothing says otherwise" },
+    },
+    {
+        "id": "climate-pledge-arena",
+        "wikidata": "Q977529",
+        "division": "pacific",
+        "en": { "title": "Climate Pledge Arena", "revision": 1380851727 },
+        "seats": { "hockey": 17151, "source": "wikipedia", "wikidata": 18000, "read": "the article's seating capacity for ice hockey, 17,151, which the infobox gives too; Wikidata's one capacity (18,000) is near the basketball one (18,300)" },
+        "tiers": { "count": 2, "basis": "documented", "read": "the article tells of the upper level and the lower level, most of the lower level being below street level since the 2021 rebuild: two seating levels" },
+        "roof": { "kind": "fixed", "basis": "documented", "read": "the article says the original 1962 roof's shape was kept and carried on a fixed roof of steel trusses (the first, cable-hung, roof being taken down), and that the roof is landmarked" },
+    },
+    {
+        "id": "rogers-arena",
+        "wikidata": "Q517318",
+        "division": "pacific",
+        "en": { "title": "Rogers Arena", "revision": 1379918849 },
+        "seats": { "hockey": 18871, "source": "wikipedia", "wikidata": 18422, "read": "the infobox's present figure for ice hockey (18,871, from 2018); Wikidata's 18,422 is the 1995 figure and the first the infobox lists" },
+        "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; OpenStreetMap maps four building levels, which are floors, not seating bowls" },
+        "roof": { "kind": "fixed", "basis": "plausible", "read": "an indoor arena: a fixed roof, as nothing says otherwise" },
+    },
+    {
+        "id": "t-mobile-arena",
+        "wikidata": "Q3338973",
+        "division": "pacific",
+        "en": { "title": "T-Mobile Arena", "revision": 1379155307 },
+        "seats": { "hockey": 17500, "source": "wikipedia", "wikidata": 20000, "read": "the infobox's figure for ice hockey, 17,500 (20,000 with standing room); Wikidata's one capacity (20,000) is the one with standing room" },
+        "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" },
+    },
+];

package/dist/venues.geo.d.ts

@@ -0,0 +1,60 @@
+import type { Pt } from "./crowd.ts";
+/** A point as `[longitude, latitude]`, in degrees, the order OpenStreetMap's GeoJSON gives. */
+export type LonLat = readonly [number, number];
+/** Points in degrees as `[east, north]` metres from `origin`, on a plane tangent to the earth there (good to a few centimetres over a building's size). */
+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;
+/** 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. */
+export declare function areaOf(points: readonly Pt[]): number;
+/** The centre of mass of a polygon's area. */
+export declare function centroidOf(points: readonly Pt[]): Pt;
+/** The convex hull of some points (Andrew's monotone chain), counter-clockwise. */
+export declare function hullOf(points: readonly Pt[]): Pt[];
+/** The heading, in degrees clockwise from north, of a direction given as east and north components, taken modulo 180 (an axis has no head): 0 to under 180. */
+export declare const axisHeading: (east: number, north: number) => number;
+/** The smallest rectangle (by area) that encloses some points: its long side's heading, its length and its width, in the units of the points. */
+export declare function smallestBox(points: readonly Pt[]): {
+    heading: number;
+    length: number;
+    width: number;
+};
+/**
+ * A point given as east and north metres, in the drawing's frame, for a rink whose long side runs along `heading` (degrees clockwise from north, 0 to under 180): x along the rink's long side, y across it and down the page,
+ * so that the picture is the map turned and not mirrored. Metres stay metres.
+ */
+export declare function turnedTo(heading: number, [east, north]: Pt): Pt;
+/** The way north points in the drawing, in degrees clockwise from the top of the page, for a rink along `heading`. 90 less the heading: a rink that runs east-west has north at the top. */
+export declare const northOn: (heading: number) => number;
+/** A ring with points that lie within `tolerance` of the line between their neighbours taken out (Douglas and Peucker), the ends kept: a ring is a list of points not repeating its first. */
+export declare function simplified(ring: readonly Pt[], tolerance: number): Pt[];
+/** Whether a point is in a polygon (even-odd). */
+export declare function inside(points: readonly Pt[], [x, y]: Pt): boolean;
+/** The smallest box round some points. */
+export declare function boxOf(points: readonly Pt[]): {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+};
+/** The distance from a point to the nearest edge of a polygon. */
+export declare function edgeDistance(points: readonly Pt[], [x, y]: Pt): number;
+/** What `coreOf` finds: the building's main hall, as the largest rectangle that lies inside its outline. */
+export interface Core {
+    /** The heading of the rectangle's long side, 0 to under 180, degrees clockwise from north. */
+    heading: number;
+    /** The rectangle's long and short sides, in the units of the points. */
+    length: number;
+    width: number;
+    /** The middle of the rectangle, as east and north from the points' origin. */
+    centre: Pt;
+    /** How much the best direction beats the worst: the largest rectangle's area over the smallest, over every direction. A round building has 1; a building with a direction has more. */
+    strength: number;
+}
+/**
+ * The main hall of a building: the largest rectangle inside its outline over every direction (`STEP` degrees apart), which does not see a wing, a plaza or a ramp that a rectangle cannot fill. Its long side is the
+ * building's axis, its middle the middle of the hall, and `strength` how much of a direction the building has (a round one has none). Ties between a direction and the one at a right angle go to the longer rectangle.
+ */
+export declare function coreOf(points: readonly Pt[]): Core;