@johnmorrisdotca/kyogijo-stadiums 0.49.0 → 0.50.0

package/dist/circuits.geo.js

@@ -0,0 +1,105 @@
+/** The length of a line, closed into a ring when `closed`. */
+export function lineLength(points, closed) {
+    let sum = 0;
+    const last = closed ? points.length : points.length - 1;
+    for (let i = 0; i < last; i += 1) {
+        const p = points[i];
+        const q = points[(i + 1) % points.length];
+        sum += Math.hypot(q[0] - p[0], q[1] - p[1]);
+    }
+    return sum;
+}
+/** The distance from `p` to the segment from `a` to `b`, and how far along it (0 to 1) the nearest point is. */
+function toSegment(p, a, b) {
+    const dx = b[0] - a[0];
+    const dy = b[1] - a[1];
+    const len2 = dx * dx + dy * dy;
+    const t = len2 === 0 ? 0 : Math.min(1, Math.max(0, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / len2));
+    return { d: Math.hypot(a[0] + t * dx - p[0], a[1] + t * dy - p[1]), t };
+}
+/** An open line with the points that lie within `tolerance` of the line between their neighbours taken out (Douglas and Peucker); the two ends are kept. */
+export function simplifyLine(points, tolerance) {
+    if (points.length < 3)
+        return [...points];
+    const keep = new Array(points.length).fill(false);
+    keep[0] = true;
+    keep[points.length - 1] = true;
+    const stack = [[0, points.length - 1]];
+    while (stack.length > 0) {
+        const [from, to] = stack.pop();
+        let at = -1;
+        let most = tolerance;
+        for (let i = from + 1; i < to; i += 1) {
+            const { d } = toSegment(points[i], points[from], points[to]);
+            if (d > most)
+                [at, most] = [i, d];
+        }
+        if (at >= 0) {
+            keep[at] = true;
+            stack.push([from, at], [at, to]);
+        }
+    }
+    return points.filter((_, i) => keep[i]);
+}
+/** A ring (the first point not repeated) made simpler as a line from its first point round to it again, so that the first point, the start of a lap, stays where it is. */
+export function simplifyLoop(points, tolerance) {
+    const line = simplifyLine([...points, points[0]], tolerance);
+    return line.slice(0, -1);
+}
+/** Where on a line (closed when `closed`) the point nearest `p` is: the segment it is on (from point `i` to the next), how far round from the first point that is, the point itself and the distance to it. */
+export function nearestOn(points, p, closed) {
+    let best = { i: 0, along: 0, at: points[0], d: Infinity };
+    let walked = 0;
+    const last = closed ? points.length : points.length - 1;
+    for (let i = 0; i < last; i += 1) {
+        const a = points[i];
+        const b = points[(i + 1) % points.length];
+        const long = Math.hypot(b[0] - a[0], b[1] - a[1]);
+        const { d, t } = toSegment(p, a, b);
+        if (d < best.d)
+            best = { i, along: walked + t * long, at: [a[0] + t * (b[0] - a[0]), a[1] + t * (b[1] - a[1])], d };
+        walked += long;
+    }
+    return best;
+}
+/** The point and the unit direction of a ring `along` units round from its first point (wrapped round the lap). */
+export function pointAlong(points, along) {
+    const total = lineLength(points, true);
+    let left = ((along % total) + total) % total;
+    for (let i = 0; i < points.length; i += 1) {
+        const a = points[i];
+        const b = points[(i + 1) % points.length];
+        const long = Math.hypot(b[0] - a[0], b[1] - a[1]);
+        if (left <= long || i === points.length - 1) {
+            const t = long === 0 ? 0 : Math.min(1, left / long);
+            return { at: [a[0] + t * (b[0] - a[0]), a[1] + t * (b[1] - a[1])], dir: long === 0 ? [1, 0] : [(b[0] - a[0]) / long, (b[1] - a[1]) / long] };
+        }
+        left -= long;
+    }
+    return { at: points[0], dir: [1, 0] };
+}
+/**
+ * Which way a ring bends at `along`, worked out over `reach` either side: the unit direction of travel there and the side the bend turns to (`1` to the left of travel in a frame whose y grows down the page, as an SVG's does,
+ * `-1` to the right, `0` straight).
+ */
+export function bendAt(points, along, reach) {
+    const before = pointAlong(points, along - reach).at;
+    const here = pointAlong(points, along);
+    const after = pointAlong(points, along + reach).at;
+    const a = [here.at[0] - before[0], here.at[1] - before[1]];
+    const b = [after[0] - here.at[0], after[1] - here.at[1]];
+    const cross = a[0] * b[1] - a[1] * b[0];
+    const scale = Math.hypot(...a) * Math.hypot(...b);
+    const side = scale === 0 || Math.abs(cross / scale) < 0.02 ? 0 : cross < 0 ? 1 : -1;
+    return { dir: here.dir, side };
+}
+/** The signed area of a ring (the shoelace sum, halved): positive when it runs clockwise on a page whose y grows down. */
+export function signedAreaOf(points) {
+    let sum = 0;
+    for (let i = 0; i < points.length; i += 1) {
+        const p = points[i];
+        const q = points[(i + 1) % points.length];
+        sum += p[0] * q[1] - q[0] * p[1];
+    }
+    return sum / 2;
+}

package/dist/circuits.js

@@ -0,0 +1,73 @@
+import { CIRCUIT_DATA } from "./circuits.data.js";
+import { CIRCUIT_OSM } from "./circuits.osm.data.js";
+import { bendAt, lineLength, nearestOn } from "./circuits.geo.js";
+import { FEET_PER_METRE as FT } from "./geometry.js";
+import { metresFrom, northOn, smallestBox, turnedTo } from "./venues.geo.js";
+/** The credit a drawing made from OpenStreetMap's data carries (the same words as the venues'). */
+export const CIRCUIT_ATTRIBUTION = "(c) OpenStreetMap contributors, ODbL 1.0, openstreetmap.org/copyright";
+/** Every circuit, in the order of the data. */
+export const CIRCUITS = Object.freeze(CIRCUIT_DATA.map((c) => {
+    const osm = CIRCUIT_OSM[c.id];
+    if (osm === undefined)
+        throw new Error(`the circuit ${c.id} has no OpenStreetMap record`);
+    return Object.freeze({ ...c, osm });
+}));
+/** The keys of the circuits. */
+export const CIRCUIT_IDS = Object.freeze(CIRCUITS.map((c) => c.id));
+/** A circuit by its key, or `undefined`. */
+export const circuitById = (id) => CIRCUITS.find((c) => c.id === id);
+const points = (osm) => [...osm.lap, ...osm.pitLane.line, ...osm.area.ring, ...(osm.pitBuilding?.ring ?? [])];
+/** A circuit's plan: its lap, pit lane, ground, pit building, turns, start and finish in the drawing's frame. */
+export function circuitPlan(circuit) {
+    const osm = circuit.osm;
+    const all = points(osm);
+    const lons = all.map((p) => p[0]);
+    const lats = all.map((p) => p[1]);
+    const origin = [(Math.min(...lons) + Math.max(...lons)) / 2, (Math.min(...lats) + Math.max(...lats)) / 2];
+    const lapMetres = metresFrom(origin, osm.lap);
+    const heading = smallestBox(lapMetres).heading;
+    const frame = (ring) => metresFrom(origin, ring).map((p) => {
+        const [x, y] = turnedTo(heading, p);
+        return [x * FT, y * FT];
+    });
+    const lap = frame(osm.lap);
+    const place = (at) => {
+        const near = nearestOn(lap, frame([at])[0], true);
+        const bend = bendAt(lap, near.along, 30 * FT);
+        return { at: near.at, dir: bend.dir, along: near.along };
+    };
+    const turns = osm.turns.map((t) => {
+        const near = nearestOn(lap, frame([t.at])[0], true);
+        const bend = bendAt(lap, near.along, 40 * FT);
+        return { n: t.n, at: near.at, along: near.along, dir: bend.dir, side: bend.side };
+    });
+    const pitLane = frame(osm.pitLane.line);
+    const area = frame(osm.area.ring);
+    const building = osm.pitBuilding === undefined ? undefined : { ring: frame(osm.pitBuilding.ring), height: osm.pitBuilding.height * FT };
+    const xs = [...lap, ...pitLane, ...area, ...(building?.ring ?? [])].map((p) => p[0]);
+    const ys = [...lap, ...pitLane, ...area, ...(building?.ring ?? [])].map((p) => p[1]);
+    return {
+        circuit,
+        origin,
+        heading,
+        north: northOn(heading),
+        lap,
+        measured: lineLength(lapMetres, true),
+        pitLane,
+        area,
+        ...(building === undefined ? {} : { building }),
+        turns,
+        start: place(osm.start.at),
+        finish: place(osm.finish.at),
+        width: circuit.width.value * FT,
+        pitWidth: circuit.pitLaneWidth.value * FT,
+        box: { x0: Math.min(...xs), y0: Math.min(...ys), x1: Math.max(...xs), y1: Math.max(...ys) },
+    };
+}
+/** The circuit a set of options names, or an error that lists the keys. */
+export function circuitOf(id) {
+    const found = circuitById(id);
+    if (found === undefined)
+        throw new Error(`no circuit "${String(id)}": the circuits are ${CIRCUIT_IDS.join(", ")}`);
+    return found;
+}

package/dist/circuits.osm.data.d.ts

@@ -0,0 +1,2 @@
+import type { CircuitOsm } from "./circuits.types.ts";
+export declare const CIRCUIT_OSM: Record<string, CircuitOsm>;

package/dist/circuits.osm.data.js

@@ -0,0 +1,188 @@
+export const CIRCUIT_OSM = {
+    "las-vegas": {
+        "source": "relation/16696508",
+        "read": "2026-11-03",
+        "base": "2026-11-03T08:11:25Z",
+        "licence": "ODbL-1.0",
+        "attribution": "(c) OpenStreetMap contributors, ODbL 1.0, openstreetmap.org/copyright",
+        "points": 228,
+        "tolerance": 0.5,
+        "start": { "source": "node/13016217986", "at": [-115.161882, 36.109284] },
+        "finish": { "source": "node/13016217985", "at": [-115.16256, 36.108665] },
+        "turns": [
+            { "n": 1, "source": "node/11348753612", "at": [-115.160364, 36.1107] },
+            { "n": 2, "source": "node/11348753615", "at": [-115.160527, 36.111068] },
+            { "n": 3, "source": "node/11348753622", "at": [-115.162922, 36.110443] },
+            { "n": 4, "source": "node/5717585567", "at": [-115.163928, 36.111154] },
+            { "n": 5, "source": "node/137743393", "at": [-115.163995, 36.119208] },
+            { "n": 6, "source": "node/12626696512", "at": [-115.161185, 36.119173] },
+            { "n": 7, "source": "node/12638889512", "at": [-115.160113, 36.120741] },
+            { "n": 8, "source": "node/12638889528", "at": [-115.160671, 36.120939] },
+            { "n": 9, "source": "node/12059212382", "at": [-115.160406, 36.122236] },
+            { "n": 10, "source": "node/137402143", "at": [-115.165999, 36.123073] },
+            { "n": 11, "source": "node/13250780586", "at": [-115.166888, 36.124717] },
+            { "n": 12, "source": "node/1490596713", "at": [-115.169378, 36.125559] },
+            { "n": 13, "source": "node/1598856720", "at": [-115.172521, 36.120102] },
+            { "n": 14, "source": "node/2852160857", "at": [-115.173152, 36.108811] },
+            { "n": 15, "source": "node/2852160859", "at": [-115.172805, 36.108527] },
+            { "n": 16, "source": "node/2852160864", "at": [-115.171797, 36.10798] },
+            { "n": 17, "source": "node/13341696778", "at": [-115.163901, 36.10797] },
+        ],
+        "pitLane": { "source": "way/1223479152", "line": [
+                [-115.163901, 36.10797],
+                [-115.163719, 36.108128],
+                [-115.163534, 36.108211],
+                [-115.163399, 36.108284],
+                [-115.163327, 36.108348],
+                [-115.163159, 36.108544],
+                [-115.163088, 36.108588],
+                [-115.163006, 36.108606],
+                [-115.162864, 36.108617],
+                [-115.162772, 36.108643],
+                [-115.160585, 36.110632],
+                [-115.160527, 36.110733],
+                [-115.160525, 36.110799],
+                [-115.160546, 36.110885],
+                [-115.160615, 36.110975],
+                [-115.160786, 36.111152],
+            ] },
+        "area": { "source": "way/233786564", "ring": [
+                [-115.159474, 36.108123],
+                [-115.159465, 36.109009],
+                [-115.159463, 36.111419],
+                [-115.163831, 36.111463],
+                [-115.16387, 36.111421],
+                [-115.163831, 36.108924],
+                [-115.16384, 36.108175],
+                [-115.163275, 36.108185],
+                [-115.163113, 36.108111],
+            ] },
+        "pitBuilding": { "source": "way/1198427833", "height": 19.5, "levels": 4, "ring": [
+                [-115.160882, 36.110929],
+                [-115.160837, 36.110969],
+                [-115.160746, 36.110905],
+                [-115.160791, 36.110864],
+                [-115.160627, 36.110748],
+                [-115.162844, 36.108712],
+                [-115.16312, 36.108908],
+                [-115.162957, 36.109058],
+                [-115.163191, 36.108998],
+                [-115.163351, 36.109117],
+                [-115.162718, 36.109277],
+                [-115.16103, 36.110828],
+                [-115.161186, 36.11098],
+                [-115.161052, 36.111078],
+                [-115.160911, 36.111007],
+                [-115.160944, 36.110973],
+            ] },
+        "lap": [
+            [-115.161882, 36.109284],
+            [-115.160457, 36.110584],
+            [-115.160364, 36.1107],
+            [-115.160339, 36.110795],
+            [-115.160346, 36.110874],
+            [-115.160416, 36.110984],
+            [-115.160527, 36.111068],
+            [-115.160644, 36.111116],
+            [-115.160786, 36.111152],
+            [-115.160999, 36.111176],
+            [-115.161206, 36.111167],
+            [-115.161388, 36.111125],
+            [-115.161573, 36.111048],
+            [-115.16184, 36.110903],
+            [-115.162253, 36.110584],
+            [-115.162388, 36.110509],
+            [-115.162551, 36.110465],
+            [-115.162753, 36.110441],
+            [-115.162922, 36.110443],
+            [-115.163104, 36.110489],
+            [-115.163265, 36.11054],
+            [-115.163431, 36.110615],
+            [-115.163611, 36.11074],
+            [-115.163758, 36.110892],
+            [-115.163928, 36.111154],
+            [-115.163941, 36.111772],
+            [-115.163941, 36.11265],
+            [-115.163969, 36.114338],
+            [-115.163963, 36.115729],
+            [-115.163995, 36.119208],
+            [-115.162977, 36.119205],
+            [-115.161185, 36.119173],
+            [-115.160922, 36.119319],
+            [-115.160561, 36.119603],
+            [-115.1604, 36.119784],
+            [-115.160199, 36.120147],
+            [-115.160142, 36.120366],
+            [-115.160112, 36.120615],
+            [-115.160113, 36.120741],
+            [-115.160393, 36.120792],
+            [-115.160477, 36.120812],
+            [-115.160518, 36.12083],
+            [-115.160612, 36.120889],
+            [-115.160671, 36.120939],
+            [-115.160701, 36.120982],
+            [-115.160739, 36.121078],
+            [-115.160746, 36.121199],
+            [-115.160715, 36.121326],
+            [-115.160619, 36.121508],
+            [-115.160428, 36.121821],
+            [-115.160418, 36.121862],
+            [-115.160406, 36.122236],
+            [-115.161621, 36.122255],
+            [-115.163038, 36.122292],
+            [-115.16404, 36.12229],
+            [-115.164161, 36.122469],
+            [-115.164789, 36.122495],
+            [-115.165233, 36.122578],
+            [-115.165486, 36.122681],
+            [-115.165771, 36.122882],
+            [-115.165999, 36.123073],
+            [-115.166099, 36.123197],
+            [-115.166263, 36.123475],
+            [-115.166719, 36.124462],
+            [-115.1668, 36.124594],
+            [-115.166888, 36.124717],
+            [-115.166993, 36.124807],
+            [-115.167403, 36.125109],
+            [-115.167607, 36.125224],
+            [-115.167978, 36.125335],
+            [-115.168348, 36.125409],
+            [-115.169152, 36.125532],
+            [-115.169378, 36.125559],
+            [-115.170175, 36.124296],
+            [-115.170827, 36.123304],
+            [-115.1716, 36.122216],
+            [-115.172014, 36.121456],
+            [-115.17229, 36.120739],
+            [-115.172521, 36.120102],
+            [-115.172634, 36.119746],
+            [-115.172763, 36.119258],
+            [-115.172829, 36.118921],
+            [-115.172938, 36.118154],
+            [-115.172984, 36.117475],
+            [-115.172992, 36.115944],
+            [-115.172983, 36.11477],
+            [-115.17303, 36.114029],
+            [-115.173048, 36.113017],
+            [-115.173134, 36.110958],
+            [-115.173145, 36.109883],
+            [-115.173142, 36.109147],
+            [-115.173152, 36.108811],
+            [-115.172561, 36.108329],
+            [-115.172342, 36.108166],
+            [-115.172192, 36.108065],
+            [-115.172108, 36.108025],
+            [-115.172026, 36.108002],
+            [-115.171915, 36.107986],
+            [-115.171283, 36.107967],
+            [-115.170195, 36.107965],
+            [-115.168707, 36.10795],
+            [-115.164027, 36.107952],
+            [-115.163901, 36.10797],
+            [-115.163509, 36.10809],
+            [-115.163145, 36.108223],
+            [-115.162981, 36.108306],
+            [-115.162837, 36.108412],
+        ],
+    },
+};

package/dist/circuits.style.d.ts

@@ -0,0 +1,5 @@
+/** The colours in light and in dark. */
+export declare const CIRCUIT_LIGHT = "--ky-ci-ground:#eceae3;--ky-ci-area:#dcd7cb;--ky-ci-area-edge:#bdb6a6;--ky-ci-building:#c2bbad;--ky-ci-building-edge:#7f786b;--ky-ci-track:#3a3f46;--ky-ci-edge:#ffffff;--ky-ci-halo:rgba(58,63,70,.16);--ky-ci-pit:#5d636b;--ky-ci-line:#ffffff;--ky-ci-check:#15181c;--ky-ci-arrow:#f2c230;--ky-ci-arrow-edge:#3a3f46;--ky-ci-badge:#14213d;--ky-ci-badge-ink:#ffffff;--ky-ci-leader:#14213d;--ky-ci-ink:#1f2320;--ky-ci-muted:#4b535c";
+export declare const CIRCUIT_DARK = "--ky-ci-ground:#10151b;--ky-ci-area:#1b232c;--ky-ci-area-edge:#334150;--ky-ci-building:#3a4756;--ky-ci-building-edge:#6f7f90;--ky-ci-track:#5d646e;--ky-ci-edge:#e6e9ed;--ky-ci-halo:rgba(230,233,237,.1);--ky-ci-pit:#7a838e;--ky-ci-line:#ffffff;--ky-ci-check:#0b0d10;--ky-ci-arrow:#f2c230;--ky-ci-arrow-edge:#10151b;--ky-ci-badge:#e9edf2;--ky-ci-badge-ink:#10151b;--ky-ci-leader:#c4ccd5;--ky-ci-ink:#eef1f4;--ky-ci-muted:#aab3bd";
+/** The rules of a circuit's drawing, and of the turn markers and the pit building of its 3D view (`.ky-turn`). */
+export declare const KYOGIJO_CIRCUIT_STYLE: string;

package/dist/circuits.style.js

@@ -0,0 +1,34 @@
+// The rules of a circuit's drawing and of what stands up in its 3D view, light and dark. The colours are custom properties (`--ky-ci-*`) a page can set; `:where` keeps their weight at nothing so that a page's own win. The
+// drawing follows the device and the page, and a `data-theme` of light or dark on it or on the page forces one. Nothing here is a team's, a race's or a sponsor's colour: asphalt, paint and paper.
+/** The colours in light and in dark. */
+export const CIRCUIT_LIGHT = "--ky-ci-ground:#eceae3;--ky-ci-area:#dcd7cb;--ky-ci-area-edge:#bdb6a6;--ky-ci-building:#c2bbad;--ky-ci-building-edge:#7f786b;--ky-ci-track:#3a3f46;--ky-ci-edge:#ffffff;--ky-ci-halo:rgba(58,63,70,.16);--ky-ci-pit:#5d636b;--ky-ci-line:#ffffff;--ky-ci-check:#15181c;--ky-ci-arrow:#f2c230;--ky-ci-arrow-edge:#3a3f46;--ky-ci-badge:#14213d;--ky-ci-badge-ink:#ffffff;--ky-ci-leader:#14213d;--ky-ci-ink:#1f2320;--ky-ci-muted:#4b535c";
+export const CIRCUIT_DARK = "--ky-ci-ground:#10151b;--ky-ci-area:#1b232c;--ky-ci-area-edge:#334150;--ky-ci-building:#3a4756;--ky-ci-building-edge:#6f7f90;--ky-ci-track:#5d646e;--ky-ci-edge:#e6e9ed;--ky-ci-halo:rgba(230,233,237,.1);--ky-ci-pit:#7a838e;--ky-ci-line:#ffffff;--ky-ci-check:#0b0d10;--ky-ci-arrow:#f2c230;--ky-ci-arrow-edge:#10151b;--ky-ci-badge:#e9edf2;--ky-ci-badge-ink:#10151b;--ky-ci-leader:#c4ccd5;--ky-ci-ink:#eef1f4;--ky-ci-muted:#aab3bd";
+/** The rules of a circuit's drawing, and of the turn markers and the pit building of its 3D view (`.ky-turn`). */
+export const KYOGIJO_CIRCUIT_STYLE = `
+:where(.ky-circuit,.ky-turn){${CIRCUIT_LIGHT}}
+@media (prefers-color-scheme:dark){:where(html:not([data-theme=light]) .ky-circuit:not([data-theme=light]),html:not([data-theme=light]) .ky-turn:not([data-theme=light])){${CIRCUIT_DARK}}}
+:where(html[data-theme=dark] .ky-circuit,.ky-circuit[data-theme=dark],html[data-theme=dark] .ky-turn,.ky-turn[data-theme=dark]){${CIRCUIT_DARK}}
+:where(.ky-circuit){--ky-font:system-ui,-apple-system,"Segoe UI","Hiragino Sans","Noto Sans JP",sans-serif;display:block;width:100%;height:auto;font-family:var(--ky-font)}
+.ky-circuit .ky-ci-ground{fill:var(--ky-ci-ground)}
+.ky-circuit .ky-ci-area{fill:var(--ky-ci-area);stroke:var(--ky-ci-area-edge);stroke-linejoin:round}
+.ky-circuit .ky-ci-building{fill:var(--ky-ci-building);stroke:var(--ky-ci-building-edge);stroke-linejoin:round}
+.ky-circuit .ky-ci-halo{fill:none;stroke:var(--ky-ci-halo);stroke-linejoin:round;stroke-linecap:round}
+.ky-circuit .ky-ci-edge{fill:none;stroke:var(--ky-ci-edge);stroke-linejoin:round;stroke-linecap:round}
+.ky-circuit .ky-ci-track{fill:none;stroke:var(--ky-ci-track);stroke-linejoin:round;stroke-linecap:round}
+.ky-circuit .ky-ci-pit{fill:none;stroke:var(--ky-ci-pit);stroke-linejoin:round;stroke-linecap:round}
+.ky-circuit .ky-ci-start{stroke:var(--ky-ci-line);stroke-linecap:butt}
+.ky-circuit .ky-ci-check-a{fill:var(--ky-ci-check)}
+.ky-circuit .ky-ci-check-b{fill:var(--ky-ci-line)}
+.ky-circuit .ky-ci-arrow{fill:var(--ky-ci-arrow);stroke:var(--ky-ci-arrow-edge);stroke-linejoin:round}
+.ky-circuit .ky-ci-leader{stroke:var(--ky-ci-leader);fill:none;stroke-linecap:round}
+.ky-circuit .ky-ci-badge,.ky-turn .u-ci-badge{fill:var(--ky-ci-badge);stroke:var(--ky-ci-ground)}
+.ky-circuit .ky-ci-badge-n,.ky-turn .u-ci-badge-n{fill:var(--ky-ci-badge-ink);font-family:var(--ky-font,system-ui,sans-serif);font-weight:800;text-anchor:middle;font-variant-numeric:tabular-nums}
+.ky-circuit .ky-ci-name{fill:var(--ky-ci-ink);font-family:var(--ky-font);font-weight:800}
+.ky-circuit .ky-ci-facts{fill:var(--ky-ci-muted);font-family:var(--ky-font);font-weight:700;font-variant-numeric:tabular-nums}
+.ky-circuit .ky-ci-north{fill:var(--ky-ci-ink);stroke:var(--ky-ci-ink);stroke-linejoin:round;stroke-linecap:round}
+.ky-circuit .ky-ci-north-n{fill:none;stroke:var(--ky-ci-ink);stroke-linejoin:round;stroke-linecap:round}
+.ky-circuit .ky-ci-scale{fill:none;stroke:var(--ky-ci-ink);stroke-linecap:butt}
+.ky-circuit .ky-ci-scale-fill{fill:var(--ky-ci-ink)}
+.ky-circuit .ky-ci-scale-text{fill:var(--ky-ci-ink);font-family:var(--ky-font);font-weight:700;font-variant-numeric:tabular-nums}
+.ky-circuit .ky-ci-credit{fill:var(--ky-ci-muted);font-family:var(--ky-font);font-weight:600}
+`.trim();

package/dist/circuits.turn.d.ts

@@ -0,0 +1,43 @@
+import type { CircuitOptions } from "./circuits.types.ts";
+import { type PresetTable } from "./turn.camera.ts";
+import { type KyogijoTurn } from "./turn.dom.ts";
+import { type TurnModel, type TurnSettings } from "./turn.model.ts";
+/**
+ * The four viewpoints of a circuit: straight down, the main camera high over the long side of the lap, the end-on view along it and the low corner. A lap is kilometres across and flat, so the eye is kept higher than
+ * a single surface's.
+ */
+export declare const CIRCUIT_PRESETS: PresetTable;
+/** The size of a turn's marker and the height of its post, in thousandths of the drawing's longer side (a marker, sized to be read: nothing of this size stands at a corner). */
+export declare const CIRCUIT_MARKER: Readonly<{
+    size: 30;
+    post: 22;
+}>;
+/** The most planes a circuit's 3D view may have: its markers (three planes each), its pit building and nothing else. A test holds every circuit to it. */
+export declare const CIRCUIT_PLANES_MAX = 120;
+/**
+ * A circuit as a 3D model: its drawing as the floor, the pit building standing on it at its mapped height, and a marker with each turn's number on a post over its bend. `settings.uprights: false` is the floor alone.
+ * A `TurnModel` like any other: `turnMarkupOf` and `mountCircuitTurn` make a view of it.
+ */
+export declare function buildCircuitTurn(options: CircuitOptions, settings?: TurnSettings): TurnModel;
+/**
+ * Mount a circuit as a 3D view in a container: the same view as `mountKyogijoTurn`'s, with the controls, the pointer, the keys and the auto-turn of every 3D view, over the circuit's drawing with its pit building and
+ * the turns' numbers standing up. Where the browser cannot turn it, the flat drawing is shown.
+ * @example
+ * ```ts no-run
+ * import { mountCircuitTurn } from "@johnmorrisdotca/kyogijo-stadiums/circuits";
+ * const view = mountCircuitTurn(document.querySelector("#lap")!, { circuit: "las-vegas" }, { preset: "corner" });
+ * view.set({ yaw: 40 });
+ * ```
+ */
+export declare function mountCircuitTurn(host: HTMLElement, options: CircuitOptions, settings?: TurnSettings): KyogijoTurn<CircuitOptions>;
+/**
+ * A circuit as the markup of a 3D view, still until a page's script makes it turn: pure, so a server can make it.
+ * @example
+ * ```ts
+ * import { circuitTurnMarkup } from "@johnmorrisdotca/kyogijo-stadiums/circuits";
+ * const html = circuitTurnMarkup({ circuit: "las-vegas" }, { preset: "broadcast" });
+ * console.log(html.includes('data-part="turn-17"'), html.includes("preserve-3d"));
+ * // true false
+ * ```
+ */
+export declare function circuitTurnMarkup(options: CircuitOptions, settings?: TurnSettings): string;

package/dist/circuits.turn.js

@@ -0,0 +1,119 @@
+// A circuit in 3D: the 3D view of `turn.ts` over the circuit's own drawing (`circuitDrawing`, its turns' badges left off the floor), with the pit building stood up at the height OpenStreetMap maps for it and each
+// turn's number on a post over its bend, turned to face the eye so that it is read from wherever the view is. Nothing is drawn a second way, and nothing moves by itself: the camera, the controls, the pointer, the
+// auto-turn (which waits for the reader and stops while the page is hidden or the view is out of sight) are every 3D view's. The model is a `TurnModel` of a few dozen planes; the floor is one SVG.
+import { circuitDrawing, circuitText } from "./circuits.draw.js";
+import { circuitOf } from "./circuits.js";
+import { CIRCUIT_WORDS } from "./circuits.words.js";
+import { blockPlanes, shellBlock } from "./context.js";
+import { hash, num } from "./format.js";
+import { FEET_PER_METRE as FT } from "./geometry.js";
+import { fill } from "./strings.core.js";
+import { TURN_PRESETS } from "./turn.camera.js";
+import { mountTurn } from "./turn.dom.js";
+import { plane, pole, thinnest } from "./turn.kit.js";
+import { turnMarkupOf } from "./turn.markup.js";
+import { WORLD_PX, openingView, sceneBox } from "./turn.model.js";
+import { planesOf } from "./uprights.js";
+/**
+ * The four viewpoints of a circuit: straight down, the main camera high over the long side of the lap, the end-on view along it and the low corner. A lap is kilometres across and flat, so the eye is kept higher than
+ * a single surface's.
+ */
+export const CIRCUIT_PRESETS = { overhead: TURN_PRESETS.overhead, broadcast: { yaw: 0, pitch: 58, zoom: 1 }, end: { yaw: -90, pitch: 62, zoom: 1 }, corner: { yaw: -35, pitch: 64, zoom: 1 } };
+/** The size of a turn's marker and the height of its post, in thousandths of the drawing's longer side (a marker, sized to be read: nothing of this size stands at a corner). */
+export const CIRCUIT_MARKER = Object.freeze({ size: 30, post: 22 });
+/** The most planes a circuit's 3D view may have: its markers (three planes each), its pit building and nothing else. A test holds every circuit to it. */
+export const CIRCUIT_PLANES_MAX = 120;
+/**
+ * A circuit as a 3D model: its drawing as the floor, the pit building standing on it at its mapped height, and a marker with each turn's number on a post over its bend. `settings.uprights: false` is the floor alone.
+ * A `TurnModel` like any other: `turnMarkupOf` and `mountCircuitTurn` make a view of it.
+ */
+export function buildCircuitTurn(options, settings = {}) {
+    const language = options.language === "ja" ? "ja" : "en";
+    // An unknown circuit throws here, naming the keys, before anything is drawn.
+    circuitOf(options.circuit);
+    const id = settings.id ?? (typeof options.id === "string" && options.id !== "" ? `${options.id}-turn` : `ky-turn-${hash(JSON.stringify([options, settings.preset]))}`);
+    const standUp = settings.uprights !== false;
+    // The floor: the drawing, its name left to the page and its turns' numbers standing up instead (on the floor too when nothing stands).
+    const drawn = circuitDrawing({ ...options, id: `${id}-floor`, label: false, turns: !standUp });
+    const plan = drawn.plan;
+    const { x: vx, y: vy, w: vw, h: vh } = drawn.viewBox;
+    const k = drawn.k;
+    const items = [];
+    if (standUp && plan.building !== undefined) {
+        const planes = blockPlanes(shellBlock("pit", plan.building.ring, plan.building.height, undefined), "pit-");
+        const [cx, cy] = plan.building.ring.reduce((s, p) => [s[0] + p[0] / plan.building.ring.length, s[1] + p[1] / plan.building.ring.length], [0, 0]);
+        items.push({ id: "pit-building", kind: "blocks", at: [cx, cy], height: plan.building.height, planes });
+    }
+    if (standUp) {
+        // Each turn's number on a post, over the badge's place beside the bend; the marker turns to face the eye and leans back to be read square on, and lies flat seen from above.
+        const size = CIRCUIT_MARKER.size * k;
+        const top = CIRCUIT_MARKER.post * k;
+        const marks = [];
+        for (const b of drawn.badges) {
+            const [x, y] = b.at;
+            const r = size / 2;
+            const svg = `<circle class="u-ci-badge" cx="${num(r)}" cy="${num(r)}" r="${num(r * 0.94)}" stroke-width="${num(r * 0.1)}"/><text class="u-ci-badge-n" x="${num(r)}" y="${num(r + r * 0.4)}" font-size="${num(r * (b.n >= 10 ? 1.05 : 1.25))}">${b.n}</text>`;
+            marks.push({ ...plane(`turn-${b.n}`, "sign", [x - r, y, top + size], [size, 0, 0], [0, 0, -size], svg), billboard: true, lean: true });
+            marks.push(...pole(`turn-${b.n}-post`, "pole", x, y, 0, top, thinnest(vw, vh), "u-pole"));
+        }
+        items.push({ id: "turns", kind: "flags", at: [(plan.box.x0 + plan.box.x1) / 2, (plan.box.y0 + plan.box.y1) / 2], height: top + size, planes: marks });
+    }
+    const area = plan.box;
+    const uprights = { items, lift: 0, thin: thinnest(vw, vh), area };
+    const planes = planesOf(uprights);
+    const scale = WORLD_PX / Math.max(vw, vh);
+    const centre = [(area.x0 + area.x1) / 2, (area.y0 + area.y1) / 2];
+    const w = CIRCUIT_WORDS[language];
+    const standing = !standUp ? "" : plan.building === undefined ? w.standingNoBuilding : fill(w.standing, { height: num(Math.round((plan.building.height / FT) * 10) / 10) });
+    const { title, description } = circuitText(plan, language, standing);
+    const surfaceLike = { sport: "circuit", language, ...(options.theme === undefined ? {} : { theme: options.theme }) };
+    return {
+        id,
+        language,
+        options: surfaceLike,
+        title,
+        description,
+        standing,
+        floor: drawn.svg,
+        viewBox: { x: vx, y: vy, w: vw, h: vh },
+        scale,
+        uprights,
+        defs: "",
+        crowdStyle: "",
+        venue: false,
+        look: undefined,
+        planes,
+        box: sceneBox(planes, area, 0, centre, scale),
+        centre,
+        view: openingView({ preset: "broadcast", ...settings }, CIRCUIT_PRESETS),
+        turnable: true,
+        presets: CIRCUIT_PRESETS,
+        flat: circuitDrawing(options).svg,
+    };
+}
+/**
+ * Mount a circuit as a 3D view in a container: the same view as `mountKyogijoTurn`'s, with the controls, the pointer, the keys and the auto-turn of every 3D view, over the circuit's drawing with its pit building and
+ * the turns' numbers standing up. Where the browser cannot turn it, the flat drawing is shown.
+ * @example
+ * ```ts no-run
+ * import { mountCircuitTurn } from "@johnmorrisdotca/kyogijo-stadiums/circuits";
+ * const view = mountCircuitTurn(document.querySelector("#lap")!, { circuit: "las-vegas" }, { preset: "corner" });
+ * view.set({ yaw: 40 });
+ * ```
+ */
+export function mountCircuitTurn(host, options, settings = {}) {
+    return mountTurn(host, options, settings, buildCircuitTurn);
+}
+/**
+ * A circuit as the markup of a 3D view, still until a page's script makes it turn: pure, so a server can make it.
+ * @example
+ * ```ts
+ * import { circuitTurnMarkup } from "@johnmorrisdotca/kyogijo-stadiums/circuits";
+ * const html = circuitTurnMarkup({ circuit: "las-vegas" }, { preset: "broadcast" });
+ * console.log(html.includes('data-part="turn-17"'), html.includes("preserve-3d"));
+ * // true false
+ * ```
+ */
+export function circuitTurnMarkup(options, settings = {}) {
+    return turnMarkupOf(buildCircuitTurn(options, settings), settings);
+}