@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.6.0

package/dist/charts.js

@@ -218,7 +218,7 @@ export function nbaShotChart(shots, options = {}) {
     const end = options.end === "left" ? "left" : "right";
     // A shot chart puts every shot at the basket it was taken at; a frame fixed to the court says where each one is.
     const shooter = frame.ends === "shooter";
-    const data = shots.map((s) => clean({ x: s.x, y: s.y, outcome: s.made === undefined ? s.outcome : s.made ? "made" : "missed", value: s.value, team: s.team, title: s.title }));
+    const data = shots.map((s) => clean({ id: s.id, x: s.x, y: s.y, outcome: s.made === undefined ? s.outcome : s.made ? "made" : "missed", value: s.value, team: s.team, title: s.title }));
     const { counts, placed: count, skipped } = countOutcomes(data);
     const entries = [{ label: w.made, outcome: "made" }, { label: w.missed, outcome: "missed" }];
     const o = drawingOptions("nba", options, w.titleNba);
@@ -330,7 +330,7 @@ export function nhlShotMap(shots, options = {}) {
     const frame = frameOf(options.from, "nhl-api");
     const o = drawingOptions("nhl", options, w.titleNhl);
     const folded = options.fold === true;
-    const given = shots.map((s) => clean({ x: s.x, y: s.y, outcome: hockeyOutcome(s), value: s.xg, team: s.team, title: s.title }));
+    const given = shots.map((s) => clean({ id: s.id, x: s.x, y: s.y, outcome: hockeyOutcome(s), value: s.xg, team: s.team, title: s.title }));
     const data = folded ? foldToRight(given, frame, o) : given;
     const { counts, placed: count, skipped } = countOutcomes(data);
     const hasXg = data.some((d) => isNum(d.value));
@@ -441,7 +441,7 @@ export function nflPassChart(passes, options = {}) {
     const data = rows.map(({ p, outcome }, i) => {
         const place_ = at[i];
         const air = isNum(p.airYards) ? p.airYards : place_ === undefined ? undefined : round(inYards(place_[0] - losFeet), 1);
-        return clean({ x: p.x, y: p.y, outcome, value: air, team: p.team, title: p.title });
+        return clean({ id: p.id, x: p.x, y: p.y, outcome, value: air, team: p.team, title: p.title });
     });
     const { counts, placed: count, skipped } = countOutcomes(data);
     const entries = [["complete", w.complete], ["incomplete", w.incomplete], ["touchdown", w.touchdown], ["interception", w.interception]].filter(([k]) => counts.has(k) || counts.size === 0 || ["complete", "incomplete"].includes(k)).map(([outcome, label]) => ({ label, outcome }));
@@ -480,7 +480,7 @@ export function nflPassChart(passes, options = {}) {
         layers.push(line);
     }
     if (options.arrows === true) {
-        const arrows = rows.filter(({ p }) => isNum(p.fromX) && isNum(p.fromY) && isNum(p.x) && isNum(p.y)).map(({ p, outcome }) => clean({ x: p.fromX, y: p.fromY, x2: p.x, y2: p.y, outcome, team: p.team, title: p.title }));
+        const arrows = rows.filter(({ p }) => isNum(p.fromX) && isNum(p.fromY) && isNum(p.x) && isNum(p.y)).map(({ p, outcome }) => clean({ id: p.id, x: p.fromX, y: p.fromY, x2: p.x, y2: p.y, outcome, team: p.team, title: p.title }));
         layers.push(clean({ kind: "arrows", id: "arrows", name: w.passes, ...where, data: arrows, style: { width: 0.7, opacity: 0.7, curve: 0.08, outcomes: { touchdown: {}, interception: {}, complete: {}, incomplete: { hollow: true } } } }));
     }
     const values = data.map((d) => d.value).filter(isNum);

package/dist/charts.pool.d.ts

@@ -0,0 +1,67 @@
+import type { PoolRace, PoolStyle } from "./pool.types.ts";
+import type { Chart, ChartOptions } from "./charts.types.ts";
+/** One split of a swimmer: the metres it covers, the seconds it took, and its pace. */
+export interface SplitRow {
+    /** The distance at which the split ends, in metres of the race. */
+    distance: number;
+    /** The seconds of the split itself, and the cumulative time at its end. */
+    seconds: number;
+    cumulative: number;
+    /** Seconds per 100 m. */
+    pace: number;
+}
+/** What a swimmer's splits come to. */
+export interface SwimmerSplits {
+    lane: number;
+    name: string;
+    splits: SplitRow[];
+}
+/** The numbers behind a splits chart. */
+export interface SplitsTotals {
+    swimmers: number;
+    /** The metres of the race and the metres between splits. */
+    distance: number;
+    splitEvery: number;
+    /** The swimmers' splits, in the order down the pool. */
+    rows: SwimmerSplits[];
+    /** The fastest split of the field: whose it is, which one (from 1) and its pace; undefined with no splits. */
+    fastest: {
+        lane: number;
+        name: string;
+        split: number;
+        seconds: number;
+        pace: number;
+    } | undefined;
+    slowest: {
+        lane: number;
+        name: string;
+        split: number;
+        seconds: number;
+        pace: number;
+    } | undefined;
+}
+/** What a splits chart takes beyond a chart's own options. */
+export interface SplitsOptions extends ChartOptions {
+    /** The pool: the course (`short` for 25 m), the lanes, the look of the water and the deck. */
+    pool?: Omit<PoolStyle, "race">;
+    /** Write each bar's time on it. On by default. */
+    labels?: boolean;
+}
+/**
+ * The splits of a race as a chart: pace bars in the lanes of a pool (`pool.race.pace`), a title, a sentence that sums it up, the numbers (`totals`) and an HTML table of every split for a reader who cannot see the
+ * drawing. The splits are cumulative times, one every 50 m (every 25 m in a short course pool) unless the race says another distance.
+ * @example
+ * ```ts
+ * import { splitsChart } from "@johnmorrisdotca/kyogijo-stadiums/charts";
+ * const chart = splitsChart({
+ *   distance: 100,
+ *   swimmers: [
+ *     { lane: 4, name: "A. Swimmer", splits: [25.1, 52.4] },
+ *     { lane: 5, name: "B. Swimmer", splits: [25.6, 52.9] },
+ *   ],
+ * });
+ * console.log(chart.totals.fastest?.name, chart.totals.fastest?.pace, chart.draw().startsWith("<svg"));
+ * // A. Swimmer 50.2 true
+ * ```
+ */
+export declare function splitsChart(race: PoolRace, options?: SplitsOptions): Chart<SplitsTotals>;

package/dist/charts.pool.js

@@ -0,0 +1,76 @@
+// The swimming chart: the splits of a race as pace bars in the lanes of the pool, with the table that stands for it. A race of 200 m in a 50 m pool is swum along its lane and back; the chart lays it out
+// flat, so that each lane is the whole race from the start (left) to the finish (right), each split a bar whose length is its share of the race and whose colour is its pace against the field's, written
+// in seconds per 100 m. Written for this package; nothing of any other package is used.
+import { drawKyogijo } from "./draw.js";
+import { esc } from "./format.js";
+import { swimPlan } from "./pool.js";
+import { formatTime, pacePer100, splitMetres } from "./pool.race.js";
+import { KYOGIJO_STRINGS, fill } from "./strings.js";
+/**
+ * The splits of a race as a chart: pace bars in the lanes of a pool (`pool.race.pace`), a title, a sentence that sums it up, the numbers (`totals`) and an HTML table of every split for a reader who cannot see the
+ * drawing. The splits are cumulative times, one every 50 m (every 25 m in a short course pool) unless the race says another distance.
+ * @example
+ * ```ts
+ * import { splitsChart } from "@johnmorrisdotca/kyogijo-stadiums/charts";
+ * const chart = splitsChart({
+ *   distance: 100,
+ *   swimmers: [
+ *     { lane: 4, name: "A. Swimmer", splits: [25.1, 52.4] },
+ *     { lane: 5, name: "B. Swimmer", splits: [25.6, 52.9] },
+ *   ],
+ * });
+ * console.log(chart.totals.fastest?.name, chart.totals.fastest?.pace, chart.draw().startsWith("<svg"));
+ * // A. Swimmer 50.2 true
+ * ```
+ */
+export function splitsChart(race, options = {}) {
+    const language = options.language === "ja" ? "ja" : "en";
+    const w = KYOGIJO_STRINGS[language].pool.chart;
+    const pool = { ...(options.pool ?? {}), race: { ...race, pace: { labels: options.labels !== false } } };
+    const plan = swimPlan({ sport: "swimming", pool });
+    const planRace = plan.race;
+    if (planRace === undefined)
+        throw new TypeError("a splits chart needs a race: { swimmers: [...] }");
+    const rows = planRace.rows.map((row) => ({
+        lane: row.lane,
+        name: row.name,
+        splits: row.splits
+            .map((cum, i) => {
+            const from = i === 0 ? 0 : row.splits[i - 1];
+            if (!Number.isFinite(cum) || !Number.isFinite(from))
+                return undefined;
+            const metres = splitMetres(i, planRace.splitEvery, planRace.distance);
+            return { distance: Math.min(planRace.distance, (i + 1) * planRace.splitEvery), seconds: Math.round((cum - from) * 100) / 100, cumulative: cum, pace: Math.round(pacePer100(from, cum, metres) * 100) / 100 };
+        })
+            .filter((split) => split !== undefined),
+    }));
+    const all = rows.flatMap((row) => row.splits.map((split, i) => ({ lane: row.lane, name: row.name, split: i + 1, seconds: split.seconds, pace: split.pace })));
+    const fastest = all.length === 0 ? undefined : all.reduce((a, b) => (b.pace < a.pace ? b : a));
+    const slowest = all.length === 0 ? undefined : all.reduce((a, b) => (b.pace > a.pace ? b : a));
+    const title = planRace.event === undefined ? w.title : `${w.title}${KYOGIJO_STRINGS[language].said.sep}${planRace.event}`;
+    const totals = { swimmers: rows.length, distance: planRace.distance, splitEvery: planRace.splitEvery, rows, fastest, slowest };
+    const summary = fastest === undefined ? "" : fill(w.summary, { n: rows.length, name: fastest.name, time: formatTime(fastest.seconds) });
+    const merged = { sport: "swimming", language, ...(options.id === undefined ? {} : { id: options.id }), title, pool, ...(options.surface ?? {}) };
+    const columns = Math.max(0, ...rows.map((row) => row.splits.length));
+    return {
+        options: merged,
+        layers: [],
+        title,
+        summary,
+        totals,
+        draw(extra = {}) {
+            return drawKyogijo({ ...merged, ...extra });
+        },
+        table() {
+            const head = [w.headLane, w.headName, ...Array.from({ length: columns }, (_, i) => `${w.headSplit} ${i + 1}`), w.headPace].map((text) => `<th scope="col">${esc(text)}</th>`).join("");
+            const body = rows
+                .map((row) => {
+                const cells = Array.from({ length: columns }, (_, i) => `<td>${row.splits[i] === undefined ? "" : `${formatTime(row.splits[i].seconds)} (${row.splits[i].pace.toFixed(2)})`}</td>`).join("");
+                const mean = row.splits.length === 0 ? "" : (row.splits.reduce((sum, s) => sum + s.pace, 0) / row.splits.length).toFixed(2);
+                return `<tr><th scope="row">${row.lane}</th><td>${esc(row.name)}</td>${cells}<td>${mean}</td></tr>`;
+            })
+                .join("");
+            return `<table class="ky-table" data-kind="splits"><caption>${esc(fill(w.caption, { event: planRace.event ?? w.title }))}</caption><thead><tr>${head}</tr></thead><tbody>${body}</tbody></table>`;
+        },
+    };
+}

package/dist/charts.skating.d.ts

@@ -0,0 +1,204 @@
+import type { Chart, ChartOptions, KeyItem } from "./charts.types.ts";
+import type { ReplayLook, ReplayTimeline } from "./replay.types.ts";
+import type { SurfaceOptions } from "./types.ts";
+import { type ElementKind } from "./skating/events.ts";
+import type { SkatingRace } from "./skating/types.ts";
+/** A skater in a race or on the ice. */
+export interface SkatingEntry {
+    name: string;
+    /** The country's code or name, for the table. */
+    country?: string;
+    /** The flag: an SVG document as text, or an `https:` or relative address, as a team's `logo`. */
+    flag?: string;
+    bib?: string | number;
+}
+/** A pair of a long track race: two skaters, one in each lane (Rule 254.2). */
+export interface SkatingPair {
+    /** The pair's number in the race, from 1. */
+    pair: number;
+    inner?: SkatingEntry;
+    outer?: SkatingEntry;
+}
+/** A starter of a short track race and the starting position he has on the line (Rule 280.2c: five positions of the 500 m and the 1000 m, from 1 on the inner side). */
+export interface SkatingStarter extends SkatingEntry {
+    position: number;
+}
+/** One skater's result in a race. Times are in seconds from the gun. */
+export interface SkatingResult extends SkatingEntry {
+    /** The place, from 1. A skater who did not finish has none. */
+    place?: number;
+    /** The pair, on the long track. */
+    pair?: number;
+    /** The lane the skater started in, on the long track: `inner` or `outer`. */
+    lane?: "inner" | "outer";
+    /** The time in seconds from the gun, or `null` for one who did not finish. */
+    time?: number | null;
+    /** The times, from the gun, at distances along the way: `{ distance: 200, time: 17.9 }`. */
+    splits?: readonly {
+        distance: number;
+        time: number;
+    }[];
+    /** The lap times in seconds, one for each lap (Rule 252), for the table. */
+    laps?: readonly number[];
+    /** `DQ`, `DNF`, `DNS` or a note of your own, for the table. */
+    note?: string;
+}
+/** What the race charts take beyond a chart's options. */
+export interface SkatingRaceOptions extends ChartOptions {
+    /** The race: the 500 m by default. */
+    race?: SkatingRace;
+}
+/** The numbers behind a draw. */
+export interface DrawTotals {
+    skaters: number;
+    /** Long track: the pairs; short track: 1. */
+    pairs: number;
+}
+/** The numbers behind results. */
+export interface SkatingResultsTotals {
+    skaters: number;
+    finished: number;
+    winner: {
+        name: string;
+        time: number;
+    } | null;
+}
+/** A time in seconds as it is written: `34.32`, `1:40.91`, `6:01.03`. */
+export declare function formatTime(seconds: number, places?: number): string;
+/**
+ * The pairs of a long track race on the start's close-up: the pair `pair` (the first by default) with each skater's name and flag behind the starting line of his lane, and an armband's colour (white
+ * for the inner lane, red for the outer: Rule 253.3.1); a table lists every pair. The starting lines are the ISU's: the 500 m on the finishing straight, the 1000 m, 1500 m, 3000 m and 5000 m on the
+ * crossing straight, where each lane's line stands a different distance from the finish.
+ * @example
+ * ```ts
+ * import { skatingPairs } from "@johnmorrisdotca/kyogijo-stadiums/skating";
+ * const chart = skatingPairs([{ pair: 1, inner: { name: "A. Skater" }, outer: { name: "B. Skater" } }], { race: "1000m" });
+ * console.log(chart.totals, chart.title);
+ * // { skaters: 2, pairs: 1 } Pairs, 1000 m
+ * ```
+ */
+export declare function skatingPairs(pairs: readonly SkatingPair[], options?: SkatingRaceOptions & {
+    pair?: number;
+}): Chart<DrawTotals> & {
+    key: KeyItem[];
+};
+/**
+ * The starting positions of a short track race on the start's close-up: the five dots of the 500 m and the 1000 m (every 1.3 m from 50 cm out from the inner side, Rule 280.2c), each with its starter's
+ * name and flag. The 500 m and the 1500 m start on the straight opposite the finishing line; the others at the finishing line.
+ * @example
+ * ```ts
+ * import { skatingGrid } from "@johnmorrisdotca/kyogijo-stadiums/skating";
+ * const chart = skatingGrid([{ position: 1, name: "A. Skater" }, { position: 2, name: "B. Skater" }], { race: "500m", surface: { league: "isu-short-track" } });
+ * console.log(chart.totals.skaters);
+ * // 2
+ * ```
+ */
+export declare function skatingGrid(starters: readonly SkatingStarter[], options?: SkatingRaceOptions): Chart<DrawTotals> & {
+    key: KeyItem[];
+};
+/**
+ * The results of a race as a leaderboard on the ice inside the track: for each skater with a place, a disc with the place (gold, silver and bronze for the first three), the name and the time; the splits
+ * as small marks along the skater's lane on the long track; and a table with the pair, the lane, the time, the splits and the lap times. Times are in seconds from the gun.
+ * @example
+ * ```ts
+ * import { skatingResults } from "@johnmorrisdotca/kyogijo-stadiums/skating";
+ * const chart = skatingResults([{ name: "A", place: 1, time: 34.3 }, { name: "B", place: 2, time: 34.5 }], { race: "500m" });
+ * console.log(chart.totals.winner?.name, chart.summary);
+ * // A A won the 500 m in 34.30.
+ * ```
+ */
+export declare function skatingResults(results: readonly SkatingResult[], options?: SkatingRaceOptions & {
+    splits?: boolean;
+    rows?: number;
+}): Chart<SkatingResultsTotals> & {
+    key: KeyItem[];
+};
+/** One skater of a replay. */
+export interface SkatingRunner extends SkatingEntry {
+    /** The time, in seconds from the gun, at which the skater finishes. */
+    time: number;
+    /** Long track: the lane the skater starts in. `inner` by default. */
+    lane?: "inner" | "outer";
+    /** Short track: the starting position, from 1 on the inner side. 1 by default. */
+    position?: number;
+    /** Times, from the gun, at distances along the way, which the skater's pace follows; without them the pace is even. */
+    splits?: readonly {
+        distance: number;
+        time: number;
+    }[];
+}
+/** What `skatingReplay` takes. */
+export interface SkatingReplayOptions extends SkatingRaceOptions {
+    /** Seconds between two frames. 0.25 by default. */
+    step?: number;
+}
+/** What `skatingReplay` gives back. */
+export interface SkatingReplay {
+    timeline: ReplayTimeline;
+    /** The drawing's options: the track with the race marked. */
+    options: SurfaceOptions;
+    /** A look for the frames: markers sized for the track, no trails, the lane or the position on them. */
+    look: ReplayLook;
+    title: string;
+    summary: string;
+    duration: number;
+}
+/** The distance a skater has skated at a time, by the splits and the finish: straight lines between them, coasting for three seconds after the finish. */
+export declare function distanceSkated(runner: SkatingRunner, total: number, t: number): number;
+/**
+ * A replay of a race: every skater, from the gun, on his own way round the track (the long track's lane changed once a lap, on the crossing straight, and the first straight of the 1000 m and the 1500 m
+ * kept in the lane; the short track's oval of 111.12 m, the starters coming in from their positions), at the pace of the splits and the finish time. The positions are in the skating frame (metres
+ * from the middle of the rink). The team races, the mass start and the relays are not replayed.
+ * @example
+ * ```ts
+ * import { skatingReplay } from "@johnmorrisdotca/kyogijo-stadiums/skating";
+ * const replay = skatingReplay([{ name: "A", lane: "inner", time: 34.4 }, { name: "B", lane: "outer", time: 34.6 }], { race: "500m" });
+ * console.log(replay.timeline.frames.length > 40, replay.duration);
+ * // true 34.6
+ * ```
+ */
+export declare function skatingReplay(runners: readonly SkatingRunner[], options?: SkatingReplayOptions): SkatingReplay;
+/** An element of a figure skating programme as it lies on the ice. */
+export interface SkatingElement {
+    /** The kind: a jump, a spin, a step sequence, a choreographic sequence, a lift, a spiral, a twizzle, a death spiral or a throw. */
+    kind: ElementKind;
+    /** The name for the table and the label: `3Lz`, `CCoSp4`, `StSq3`. */
+    name?: string;
+    /** Where it starts, in metres from the middle of the rink: x along it (positive to the right as the rink lies wide), y across (positive towards the judges). */
+    x: number;
+    y: number;
+    /** Where it ends, for an element that travels (a step sequence, a spiral). */
+    x2?: number;
+    y2?: number;
+    /** The place in the programme, from 1. */
+    order?: number;
+    /** `home` or `away`: the two layer colours, for a pair's two skaters or two programmes. */
+    team?: string;
+    /** The tooltip, and what a screen reader reads. */
+    title?: string;
+}
+/** What `figureElements` takes. */
+export interface FigureElementsOptions extends ChartOptions {
+    /** Write the name beside each mark. On by default. */
+    labels?: boolean;
+}
+/** The numbers behind the elements. */
+export interface ElementTotals {
+    elements: number;
+    /** The count of each kind. */
+    kinds: Readonly<Record<string, number>>;
+}
+/**
+ * The elements of a programme as marks on the rink: a mark for each element where it starts, its shape for its kind, the track of a step sequence or a spiral as a line to where it ends, and the order
+ * and the name beside it. Put them on the rink (`league: "isu-figure"`, the default for this chart).
+ * @example
+ * ```ts
+ * import { figureElements } from "@johnmorrisdotca/kyogijo-stadiums/skating";
+ * const chart = figureElements([{ kind: "jump", name: "3Lz", x: -12, y: 4, order: 1 }, { kind: "spin", name: "CCoSp4", x: 6, y: -3, order: 2 }]);
+ * console.log(chart.totals.elements, chart.totals.kinds.jump);
+ * // 2 1
+ * ```
+ */
+export declare function figureElements(elements: readonly SkatingElement[], options?: FigureElementsOptions): Chart<ElementTotals> & {
+    key: KeyItem[];
+};