@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.6.0

package/dist/charts-entry.d.ts

@@ -2,9 +2,14 @@ export { nbaShotChart, nflPassChart, nhlShotMap } from "./charts.ts";
 export { mlbSprayChart } from "./charts.baseball.ts";
 export { soccerGoalMouth, soccerShotMap } from "./charts.soccer.ts";
 export { CURLING_COLORS, curlingScore, curlingStones } from "./charts.curling.ts";
+export { curlingHeat } from "./charts.curling.heat.ts";
+export { CURLING_HIT_TYPES, curlingEndStats, curlingFreeGuards, curlingGuardScores, curlingHammers, curlingInPlay, curlingIsHit, curlingShotStats } from "./curling.stats.ts";
+export type { CurlingEndRecord, CurlingEndScore, CurlingEndStats, CurlingGuardEnd, CurlingGuardScores, CurlingGuards, CurlingHammerStats, CurlingInPlay, CurlingShot, CurlingShotLine, CurlingShotStats, CurlingSide, CurlingStealStats, CurlingTeamEnds } from "./curling.stats.ts";
+export { splitsChart } from "./charts.pool.ts";
+export type { SplitRow, SplitsOptions, SplitsTotals, SwimmerSplits } from "./charts.pool.ts";
 export { passNetwork } from "./charts.network.ts";
 export type { PassNetworkOptions, PassNetworkPass, PassNetworkTotals } from "./charts.network.ts";
-export type { Ball, Chart, ChartOptions, CurlingOptions, CurlingStone, CurlingStoneResult, CurlingTotals, GoalMouth, GoalMouthOptions, KeyItem, MlbSprayOptions, MlbTotals, NbaShot, NbaShotOptions, NbaTotals, NflPass, NflPassOptions, NflTotals, NhlShot, NhlShotOptions, NhlTotals, SoccerChart, SoccerShot, SoccerShotOptions, SoccerTotals, ZoneTotal } from "./charts.types.ts";
+export type { Ball, Chart, ChartOptions, CurlingHeatOptions, CurlingHeatTotals, CurlingOptions, CurlingStone, CurlingStoneResult, CurlingTotals, GoalMouth, GoalMouthOptions, KeyItem, MlbSprayOptions, MlbTotals, NbaShot, NbaShotOptions, NbaTotals, NflPass, NflPassOptions, NflTotals, NhlShot, NhlShotOptions, NhlTotals, SoccerChart, SoccerShot, SoccerShotOptions, SoccerTotals, ZoneTotal } from "./charts.types.ts";
 export { ROAD_SIZES, roadToFinal } from "./road.ts";
 export { KYOGIJO_ROAD_STYLE } from "./road.style.ts";
 export type { RoadChart, RoadDecided, RoadFinal, RoadFinalist, RoadGroupMatch, RoadMatch, RoadOptions, RoadRecord, RoadScore, RoadSize, RoadSizeInfo, RoadTotals } from "./road.types.ts";

package/dist/charts-entry.js

@@ -3,6 +3,9 @@ export { nbaShotChart, nflPassChart, nhlShotMap } from "./charts.js";
 export { mlbSprayChart } from "./charts.baseball.js";
 export { soccerGoalMouth, soccerShotMap } from "./charts.soccer.js";
 export { CURLING_COLORS, curlingScore, curlingStones } from "./charts.curling.js";
+export { curlingHeat } from "./charts.curling.heat.js";
+export { CURLING_HIT_TYPES, curlingEndStats, curlingFreeGuards, curlingGuardScores, curlingHammers, curlingInPlay, curlingIsHit, curlingShotStats } from "./curling.stats.js";
+export { splitsChart } from "./charts.pool.js";
 export { passNetwork } from "./charts.network.js";
 export { ROAD_SIZES, roadToFinal } from "./road.js";
 export { KYOGIJO_ROAD_STYLE } from "./road.style.js";

package/dist/charts.athletics.d.ts

@@ -0,0 +1,183 @@
+import type { Chart, ChartOptions, KeyItem } from "./charts.types.ts";
+import type { AthleticsFieldEvent, AthleticsRace } from "./athletics/types.ts";
+import type { ReplayLook, ReplayTimeline } from "./replay.types.ts";
+import type { SurfaceOptions } from "./types.ts";
+/** An athlete in a lane. */
+export interface AthleticsEntry {
+    /** The lane, from 1. */
+    lane: number;
+    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;
+}
+/** One athlete's result in a race. Times are in seconds from the gun. */
+export interface AthleticsResult extends AthleticsEntry {
+    /** The place, from 1. A runner who did not finish has none. */
+    place?: number;
+    /** The time in seconds from the gun, or `null` for one who did not finish. */
+    time?: number | null;
+    /** The reaction time in seconds (the time from the gun to the athlete's feet leaving the blocks), for a race with blocks. */
+    reaction?: number;
+    /** The times, from the gun, at distances along the way: `{ distance: 100, time: 10.4 }` is the time at 100 m. */
+    splits?: readonly {
+        distance: number;
+        time: number;
+    }[];
+    /** `DQ`, `DNF`, `DNS` or a note of your own, for the table. */
+    note?: string;
+}
+/** What `laneDraw`, `raceResults` and `raceReplay` take beyond a chart's options. */
+export interface AthleticsRaceOptions extends ChartOptions {
+    /** The race. The 400 m by default. */
+    race?: AthleticsRace;
+}
+/** The numbers behind a lane draw. */
+export interface LaneDrawTotals {
+    athletes: number;
+    /** The first and the last lane drawn. */
+    firstLane: number;
+    lastLane: number;
+}
+/** The numbers behind results. */
+export interface ResultsTotals {
+    athletes: number;
+    finished: number;
+    /** The winner's name and time, or null when nobody has a place. */
+    winner: {
+        name: string;
+        time: number;
+    } | null;
+    /** The quickest reaction, in seconds. */
+    quickestReaction: number | null;
+}
+/** An attempt in a jump or a throw. */
+export interface FieldAttempt {
+    athlete?: string;
+    /** The mark in metres: from the inside edge of the circle (or the javelin's arc) for a throw, from the take-off line for a jump. A foul has none. */
+    distance?: number | null;
+    /** A throw's direction, in degrees from the sector's axis (positive to the right of the throw as the athlete faces it), or a jump's sideways place in metres from the runway's middle line. 0 by default. */
+    across?: number;
+    /** False for a foul. True by default when there is a distance. */
+    valid?: boolean;
+    /** The round of the trial, from 1. */
+    round?: number;
+    /** `home` or `away`, which take the layer's two colours, or any other text. */
+    team?: string;
+    /** The tooltip, and what a screen reader reads. */
+    title?: string;
+}
+/** What `fieldMarks` takes. */
+export interface FieldMarksOptions extends ChartOptions {
+    /** The facility of the event that the marks are on, by its id (`javelin-west`, `jump-0-west`): the event's first by default. */
+    facility?: string;
+    /** Write each mark's distance beside it, not only the best's. Off by default. */
+    labels?: boolean;
+    /** For the triple jump: the take-off line is the women's (11 m from the pit) and not the men's (13 m). */
+    women?: boolean;
+}
+/** The numbers behind a field event's marks. */
+export interface FieldTotals {
+    attempts: number;
+    valid: number;
+    fouls: number;
+    best: {
+        distance: number;
+        athlete: string | undefined;
+    } | null;
+}
+/** A time in seconds as it is written: `9.58`, `1:40.91`, `2:03:59.40`. */
+export declare function formatTime(seconds: number, places?: number): string;
+/**
+ * The lane draw of a race: each athlete's name and flag on the lane of the start, behind the lane's number, for the close-up of the start (`range: "start"`, the drawing's default). The positions are the
+ * start lines' as the Manual marks them: the stagger of the 200, 400 and 800 m and the 4 x 400 m, the straight line of the sprints, the curved line of a race run without lanes.
+ * @example
+ * ```ts
+ * import { laneDraw } from "@johnmorrisdotca/kyogijo-stadiums/athletics";
+ * const chart = laneDraw([{ lane: 4, name: "M. Jacobs", country: "ITA" }, { lane: 5, name: "F. Kerley", country: "USA" }], { race: "100m" });
+ * console.log(chart.totals.athletes, chart.title);
+ * // 2 Lane draw, 100 m
+ * ```
+ */
+export declare function laneDraw(entries: readonly AthleticsEntry[], options?: AthleticsRaceOptions): Chart<LaneDrawTotals> & {
+    key: KeyItem[];
+};
+/**
+ * The results of a race on the finish line's close-up: after the line, in each lane, a disc with the place (gold, silver and bronze for the first three), the athlete's name and time; the reaction time
+ * behind the start line and the splits along the lane as small marks with their times; and a table of all of it. Times are in seconds from the gun.
+ * @example
+ * ```ts
+ * import { raceResults } from "@johnmorrisdotca/kyogijo-stadiums/athletics";
+ * const chart = raceResults([{ lane: 4, name: "M. Jacobs", place: 1, time: 9.8 }, { lane: 5, name: "F. Kerley", place: 2, time: 9.84 }], { race: "100m" });
+ * console.log(chart.totals.winner?.name, chart.summary);
+ * // M. Jacobs M. Jacobs won the 100 m in 9.80.
+ * ```
+ */
+export declare function raceResults(results: readonly AthleticsResult[], options?: AthleticsRaceOptions & {
+    splits?: boolean;
+    reactions?: boolean;
+}): Chart<ResultsTotals> & {
+    key: KeyItem[];
+};
+/** One runner of a replay. */
+export interface AthleticsRunner extends AthleticsEntry {
+    /** The time, in seconds from the gun, at which the runner finishes. */
+    time: number;
+    /** The reaction time, in seconds; the runner stays on the blocks until then. 0.15 by default. */
+    reaction?: number;
+    /** Times, from the gun, at distances along the way, which the runner's pace follows; without them the pace is even. */
+    splits?: readonly {
+        distance: number;
+        time: number;
+    }[];
+}
+/** What `raceReplay` takes. */
+export interface RaceReplayOptions extends AthleticsRaceOptions {
+    /** Seconds between two frames. 0.2 by default. */
+    step?: number;
+    /** How far past the finish line the runners go on, in metres. 8 by default. */
+    runOut?: number;
+}
+/** What `raceReplay` gives back: the timeline, the drawing's options to lay it on, a look for it and a sentence. */
+export interface RaceReplay {
+    timeline: ReplayTimeline;
+    /** The drawing's options: the stadium with the race marked. Pass them with the timeline to `drawFrame`, `createReplay` or `replayElement`. */
+    options: SurfaceOptions;
+    /** A look for the frames: the runners drawn larger, no trails, the lane numbers on them. */
+    look: ReplayLook;
+    title: string;
+    summary: string;
+    /** The time of the last runner to finish, in seconds. */
+    duration: number;
+}
+/** The distance a runner has run at a time, by the reaction time, the splits and the finish: straight lines between them, standing until the reaction. */
+export declare function distanceRun(runner: AthleticsRunner, total: number, t: number): number;
+/**
+ * A replay of a race: every runner, from the gun, on the curve of the lane (the stagger of the start as the Manual's table has it), in the pace of the reaction time, the splits and the finish time,
+ * to the line and on to a stop. A race that leaves its lanes (the 800 m after its breakline, the long races from the start) is drawn with the runners moving in to the inside. The positions are in
+ * the athletics frame (metres from the middle of the track), so the timeline is for the stadium drawn whole or close up. The relays are not replayed.
+ * @example
+ * ```ts
+ * import { raceReplay } from "@johnmorrisdotca/kyogijo-stadiums/athletics";
+ * const replay = raceReplay([{ lane: 1, name: "A", time: 10.1 }, { lane: 2, name: "B", time: 10.3 }], { race: "100m" });
+ * console.log(replay.timeline.frames.length > 40, replay.duration);
+ * // true 10.3
+ * ```
+ */
+export declare function raceReplay(runners: readonly AthleticsRunner[], options?: RaceReplayOptions): RaceReplay;
+/**
+ * The attempts of a field event as marks: each valid throw in its sector at its distance and direction, each jump in its pit at its distance from the take-off line, the best of them picked out with
+ * a ring and its distance written beside it. A foul has no mark and is in the table. Put them on the stadium (`athletics: { events: [event] }`) or on the event alone (`athletics: { layout: event }`).
+ * @example
+ * ```ts
+ * import { fieldMarks } from "@johnmorrisdotca/kyogijo-stadiums/athletics";
+ * const chart = fieldMarks("javelin-throw", [{ athlete: "A", distance: 84.2 }, { athlete: "A", distance: 88.1, across: -3 }, { athlete: "A", valid: false }]);
+ * console.log(chart.totals.best?.distance, chart.totals.fouls);
+ * // 88.1 1
+ * ```
+ */
+export declare function fieldMarks(event: AthleticsFieldEvent, attempts: readonly FieldAttempt[], options?: FieldMarksOptions): Chart<FieldTotals> & {
+    key: KeyItem[];
+};