@johnmorrisdotca/kyogijo-stadiums 0.0.0-stage → 0.4.0

package/dist/charts.curling.js

@@ -0,0 +1,196 @@
+// The curling chart: the stones of an end on the house, each in its team's colour with its number, the stones that score ringed and the shot rock
+// ringed twice, and the score of the end worked out by the rules (a stone in or touching the house counts when it is nearer the button than every
+// stone of the other team). Written for this package from World Curling's R2, R12 and Curling Canada's Rules 4 and 13; nothing of any other
+// package is used.
+import { CURLING, STONE_DIAMETER } from "./geometry.js";
+import { convertLength } from "./units.js";
+import { sheetFor } from "./sheet.js";
+import { assemble, clean, drawingOptions, keyItems, keyLayers, languageOf, round, wordsOf } from "./charts.js";
+import { fill } from "./strings.js";
+import { outlineOf } from "./outline.js";
+import { isUnit } from "./units.js";
+const R = STONE_DIAMETER / 2;
+const EPS = 1e-6;
+/** The colours of the two teams' stones, the handles' colours of a game: red and yellow. */
+export const CURLING_COLORS = { home: "#cf2e2e", away: "#f2c230" };
+const isNum = (value) => typeof value === "number" && Number.isFinite(value);
+/**
+ * Judge the stones of an end by the rules. A stone is out of play, and taken off the sheet, when it touches a sideline, when it does not come to rest
+ * wholly beyond the hog line, or when it has wholly crossed the back line. A stone with any part within 6 feet of the button (in or touching the
+ * house) can score; the team with the stone nearest the button scores one point for each of its stones that are nearer than every stone of the other
+ * team. Stones as near as each other are equal, and equal stones do not count: if the two nearest are of different teams and as near, the end is
+ * blank. Places are feet from the button (in `units`, feet by default), x across and y along.
+ * @example
+ * ```ts
+ * import { curlingScore } from "@johnmorrisdotca/kyogijo-stadiums/charts";
+ * const end = curlingScore([
+ *   { x: 0.3, y: 0.2, team: "home" },
+ *   { x: -1.5, y: 1, team: "home" },
+ *   { x: 2, y: -2, team: "away" },
+ * ]);
+ * console.log(end.scoring, end.points, end.shot);
+ * // home 2 0
+ * ```
+ */
+export function curlingScore(stones, options = {}) {
+    if (!Array.isArray(stones))
+        throw new TypeError("stones is a list of stones");
+    const unit = options.units === undefined ? "ft" : options.units;
+    if (!isUnit(unit))
+        throw new RangeError(`Unknown units "${String(unit)}": use one of ft, in, yd, m, cm, mm`);
+    const half = (options.width ?? CURLING.width) / 2;
+    const results = [];
+    let skipped = 0;
+    const near = [];
+    stones.forEach((stone, index) => {
+        if (typeof stone !== "object" || stone === null || !isNum(stone.x) || !isNum(stone.y)) {
+            skipped += 1;
+            return;
+        }
+        const x = convertLength(stone.x, unit, "ft");
+        const y = convertLength(stone.y, unit, "ft");
+        const distance = Math.hypot(x, y);
+        const inPlay = Math.abs(x) + R < half && y - R > -CURLING.hogLine && y - R <= CURLING.backLine;
+        const inHouse = inPlay && distance - R <= CURLING.rings.twelve + EPS;
+        results.push({ index, distance, inPlay, inHouse, counting: false, shot: false });
+        if (inHouse)
+            near.push({ index, distance, team: typeof stone.team === "string" && stone.team !== "" ? stone.team : "home" });
+    });
+    near.sort((a, b) => a.distance - b.distance || a.index - b.index);
+    let scoring = null;
+    let blank = true;
+    let shot = null;
+    const counting = [];
+    if (near.length > 0) {
+        const first = near[0];
+        const rival = near.find((s) => s.team !== first.team);
+        if (rival === undefined || rival.distance - first.distance > EPS) {
+            scoring = first.team;
+            blank = false;
+            shot = first.index;
+            for (const s of near)
+                if (s.team === first.team && (rival === undefined || rival.distance - s.distance > EPS))
+                    counting.push(s.index);
+        }
+    }
+    for (const r of results) {
+        r.counting = counting.includes(r.index);
+        r.shot = r.index === shot;
+    }
+    return {
+        stones: results.length,
+        inPlay: results.filter((r) => r.inPlay).length,
+        out: results.filter((r) => !r.inPlay).length,
+        counting: counting.length,
+        points: counting.length,
+        scoring,
+        shot,
+        blank,
+        skipped,
+        results,
+    };
+}
+const LOOKS = { stone: {}, counting: { hollow: true }, "shot-rock": { hollow: true, scale: 1.3 } };
+/**
+ * A chart of the stones of an end on the house: each stone as seen from above (grey granite and its team's handle, with its number), the stones
+ * that score ringed and the shot rock, the nearest, ringed twice, and the score of the end under the rules (`curlingScore`). It shows the half of
+ * the sheet from the hog line to the back line, with the free guard zone shaded, at the house on the left (the top of a tall drawing) or the right.
+ * Stones out of play are taken off, as the rules take them. `layerTable` and `chart.table()` list every stone with its distance from the button.
+ * @example
+ * ```ts
+ * import { curlingStones } from "@johnmorrisdotca/kyogijo-stadiums/charts";
+ * const chart = curlingStones(
+ *   [
+ *     { x: 0.4, y: 0.3, team: "home", number: 8 },
+ *     { x: -1.2, y: -0.8, team: "home", number: 6 },
+ *     { x: 1.9, y: 1.1, team: "away", number: 7 },
+ *     { x: 0, y: -12, team: "away", number: 3 },
+ *   ],
+ *   { end: 6, hammer: "home", names: { home: "Prairie Ridge", away: "Harbour City" } },
+ * );
+ * console.log(chart.totals.points, chart.totals.scoring, chart.title);
+ * // 2 home Curling stones, End 6
+ * ```
+ */
+export function curlingStones(stones, options = {}) {
+    if (!Array.isArray(stones))
+        throw new TypeError("stones is a list of stones");
+    const language = languageOf(options);
+    const all = wordsOf(language);
+    const w = all.charts;
+    const house = options.house === "right" ? "right" : "left";
+    const title = options.end === undefined ? w.titleCurling : `${w.titleCurling}${all.said.sep}${fill(w.curlingEnd, { n: options.end })}`;
+    const surface = options.surface ?? {};
+    // The two stone colours and the half of the sheet with the free guard zone, under whatever the caller laid over them.
+    const sheet = { show: "half", end: house, guardZone: true, ...(surface.sheet ?? {}) };
+    const o = drawingOptions("curling", { ...options, surface: { ...surface, sheet, colors: { layerHome: CURLING_COLORS.home, layerAway: CURLING_COLORS.away, ...(surface.colors ?? {}) } } }, title, { margin: 4.5 });
+    const plan = sheetFor(o);
+    const totals = curlingScore(stones, { units: options.units, width: plan.spec.width });
+    const unit = options.units ?? "ft";
+    const feet = (value) => convertLength(value, unit, "ft");
+    const name = (team) => (team === "away" ? options.names?.away ?? all.said.away : team === "home" || team === undefined ? options.names?.home ?? all.said.home : team);
+    const at = { from: "curling", units: "ft", ...(house === "left" ? { attacking: "left" } : {}) };
+    const inPlay = totals.results.filter((r) => r.inPlay);
+    const stone = (r) => stones[r.index];
+    const handles = inPlay.map((r) => {
+        const s = stone(r);
+        const notes = [r.shot ? w.curlingNoteShot : undefined, r.counting && !r.shot ? w.curlingNoteCounting : undefined].filter((n) => n !== undefined);
+        const base = s.title ?? fill(w.curlingFrom, { name: `${name(s.team)}${isNum(s.number) ? ` ${s.number}` : ""}`, d: round(r.distance, 2) });
+        return clean({
+            x: feet(s.x),
+            y: feet(s.y),
+            team: s.team ?? "home",
+            outcome: r.shot ? "shot-rock" : r.counting ? "counting" : "stone",
+            value: round(r.distance, 2),
+            title: s.title ?? `${base}${notes.length === 0 ? "" : `${all.said.sep}${notes.join(all.said.sep)}`}`,
+        });
+    });
+    const ring = (id, factor, cond, label) => {
+        const data = inPlay.filter(cond).map((r) => ({ x: feet(stone(r).x), y: feet(stone(r).y), outcome: id }));
+        return data.length === 0 ? undefined : { kind: "points", id, name: label, ...at, data, style: { shape: "circle", size: STONE_DIAMETER * factor, fill: "rgba(0,0,0,0)", stroke: "#d99a00" } };
+    };
+    const layers = [];
+    const shotRing = ring("shot-rock", 2, (r) => r.shot, w.curlingShot);
+    const countRing = ring("counting", 1.5, (r) => r.counting, w.curlingCounting);
+    if (shotRing !== undefined)
+        layers.push(shotRing);
+    if (countRing !== undefined)
+        layers.push(countRing);
+    // The granite of each stone, then its handle in the team's colour, which is the layer that carries the data.
+    layers.push({ kind: "points", id: "granite", name: w.curlingStone, ...at, data: handles.map((d) => ({ x: d.x, y: d.y })), style: { size: STONE_DIAMETER, fill: "#9aa3a9", stroke: "var(--ky-layer-edge)" } });
+    layers.push({
+        kind: "points",
+        id: "stones",
+        name: w.curlingStone,
+        title: fill(all.layers.count, { n: inPlay.length, noun: w.curlingStone.toLowerCase() === "stone" ? "stones" : w.curlingStone }),
+        ...at,
+        data: handles,
+        style: { size: STONE_DIAMETER * 0.72, outcomes: { counting: {}, "shot-rock": {}, stone: {} } },
+    });
+    if (options.numbers !== false) {
+        const numbers = inPlay.filter((r) => isNum(stone(r).number)).map((r) => ({ x: feet(stone(r).x), y: feet(stone(r).y), text: stone(r).number }));
+        if (numbers.length > 0)
+            layers.push({ kind: "text", id: "numbers", name: w.curlingStone, ...at, data: numbers, style: { size: STONE_DIAMETER * 0.4, weight: 800 } });
+    }
+    // The key: a stone, a stone that scores, the shot rock; over the half of the sheet that is shown.
+    const entries = [
+        { label: w.curlingStone, outcome: "stone" },
+        ...(totals.counting > 0 ? [{ label: w.curlingCounting, outcome: "counting" }] : []),
+        ...(totals.shot !== null ? [{ label: w.curlingShot, outcome: "shot-rock" }] : []),
+    ];
+    if (options.key !== false) {
+        const { box } = outlineOf(o);
+        const tee = house === "left" ? box.w / 2 - CURLING.teeFromMiddle : box.w / 2 + CURLING.teeFromMiddle;
+        const shown = { x: house === "left" ? tee - CURLING.backLine : tee - CURLING.hogLine - 1, w: CURLING.backLine + CURLING.hogLine + 1 };
+        layers.push(...keyLayers(o, entries, LOOKS, all, [], shown));
+    }
+    const teamName = totals.scoring === null ? "" : name(totals.scoring);
+    const parts = [
+        totals.blank ? fill(w.sumCurlingBlank, { n: totals.inPlay }) : fill(w.sumCurling, { n: totals.inPlay, team: teamName, points: totals.points }),
+        totals.out > 0 ? fill(w.curlingOut, { n: totals.out }) : "",
+        options.hammer === undefined ? "" : fill(all.said.hammer, { name: name(options.hammer) }),
+    ];
+    const chart = assemble(o, layers, { title, summary: parts.filter((p) => p !== "").join(all.said.gap), totals, tableLayers: ["stones"] });
+    chart.key = keyItems(entries, LOOKS);
+    return chart;
+}

package/dist/charts.d.ts

@@ -0,0 +1,172 @@
+import { type Frame } from "./frames.ts";
+import { isNum } from "./layers.env.ts";
+import type { Layer, LayerBase, MarkDatum, OutcomeStyle } from "./layers.types.ts";
+import { type KyogijoWords } from "./strings.ts";
+import type { Chart, ChartOptions, KeyItem, NbaShot, NbaShotOptions, NbaTotals, NflPass, NflPassOptions, NflTotals, NhlShot, NhlShotOptions, NhlTotals, ZoneTotal } from "./charts.types.ts";
+import type { Language, Sport, SurfaceOptions } from "./types.ts";
+import type { ZonesLayer } from "./heat.types.ts";
+/** The language of a chart's words. */
+export declare const languageOf: (o: ChartOptions) => Language;
+/** The words of a chart. */
+export declare const wordsOf: (language: Language) => KyogijoWords;
+export { isNum };
+/** An object without the properties that are `undefined`, so that a layer is plain data and the same input gives the same JSON. */
+export declare function clean<T extends object>(value: T): T;
+/** The ground round each surface that a chart draws, in feet: room above the surface for the key. */
+export declare const MARGIN: Readonly<Partial<Record<Sport, number>>>;
+/** A frame by name, or the frame given. */
+export declare const frameOf: (from: Frame | string | undefined, fallback: string) => Frame;
+/** What a layer's `from` is: the frame given, or the name of the one asked for (a name stays a name in the layer's JSON). */
+export declare const fromOf: (given: Frame | string | undefined, frame: Frame) => Frame | string;
+/** The outcome words of a chart and the look of each: the shape, whether it is open, a multiple of the size. */
+export type Look = OutcomeStyle;
+/** One entry of a key: what it says and the outcome whose mark it shows. */
+export interface KeyEntry {
+    label: string;
+    outcome?: string;
+}
+/** The drawing's options for a chart: the sport, the language, the title and the ground round the surface, then whatever the caller laid over them. */
+export declare function drawingOptions(sport: Sport, options: ChartOptions, title: string, extra?: Partial<SurfaceOptions>): SurfaceOptions;
+/**
+ * The key of a chart: one row of marks and their names in the margin above the surface (drawn over the ground round it), as two layers:
+ * the marks, in the look the chart's own marks have, and their words. `extra` is more words with no mark (the size of a mark, a total).
+ */
+export declare function keyLayers(o: SurfaceOptions, entries: readonly KeyEntry[], looks: Readonly<Record<string, Look>>, all: KyogijoWords, extra?: readonly string[], at?: KeyPlace): Layer[];
+/** Where a key is put when it is not centred above the whole surface: the part of the surface it is centred on (`x`, `w`) and the height of the row (`y`), in feet. */
+export interface KeyPlace {
+    x?: number;
+    w?: number;
+    y?: number;
+}
+/** The layers of the key are named `key-marks` and `key-text`. */
+export declare const isKey: (layer: Layer) => boolean;
+/** The key of a chart as data, from its entries and looks. */
+export declare function keyItems(entries: readonly KeyEntry[], looks: Readonly<Record<string, Look>>): KeyItem[];
+/** Put a chart together: the options, the layers and the ways to draw them. */
+export declare function assemble<T>(options: SurfaceOptions, layers: Layer[], parts: {
+    title: string;
+    summary: string;
+    totals: T;
+    tableLayers?: readonly string[];
+}): Chart<T> & {
+    key: KeyItem[];
+};
+/** `shot`s counted by outcome, as the words of the key and in the key's order, for a layer's description: "Made 3, Missed 5." */
+export declare function describeCounts(entries: readonly KeyEntry[], counts: ReadonlyMap<string, number>, words: KyogijoWords): string;
+/** Round to a number of decimal places. */
+export declare const round: (value: number, places?: number) => number;
+/** A percent, one decimal, or null with nothing to divide. */
+export declare const percentOf: (part: number, whole: number) => number | null;
+/** The marks counted into the zones of a layer, as zone totals. */
+export declare function zoneTotals(o: SurfaceOptions, layer: ZonesLayer): ZoneTotal[];
+/** Count marks by outcome, skipping the ones with no place. */
+export declare function countOutcomes(rows: readonly {
+    x?: number | null;
+    y?: number | null;
+    outcome?: string;
+}[]): {
+    counts: Map<string, number>;
+    placed: number;
+    skipped: number;
+};
+/** True when a mark carries a place. */
+export declare const hasPlace: (d: MarkDatum & {
+    x?: number | null;
+    y?: number | null;
+}) => boolean;
+/**
+ * Turn the shots at the left end of a surface a half turn so that every one is at the right end, in the numbers of the frame they are in.
+ * Rounded to hundredths of the frame's unit, so that a shot at the right end comes back as it was given.
+ */
+export declare function foldToRight<T extends {
+    x: number | null;
+    y: number | null;
+}>(rows: readonly T[], frame: Frame, o: SurfaceOptions): T[];
+/** The marks' places on the surface, in feet, in the same frame and ends as a layer will draw them. */
+export declare function placed(o: SurfaceOptions, layer: LayerBase, rows: readonly {
+    x?: number | null;
+    y?: number | null;
+}[]): ([number, number] | undefined)[];
+/**
+ * A shot chart for the NBA from stats.nba.com's shot data: each shot as a mark (filled when it went in, an open x when it missed), and the
+ * six shot zones coloured by their field-goal percentage, with the percentage and made over taken written on each, a legend and a table. Give
+ * `league` (the league's percentage) and the zones are coloured by how far they are above or below it, on a diverging ramp.
+ * @example
+ * ```ts
+ * import { nbaShotChart } from "@johnmorrisdotca/kyogijo-stadiums/charts";
+ * const chart = nbaShotChart(
+ *   [
+ *     { x: 0, y: 12, made: true },
+ *     { x: -231, y: 18, made: false },
+ *     { x: 120, y: 140, made: true },
+ *     { x: -30, y: 70, made: true },
+ *   ],
+ *   { league: 46, minShots: 1 },
+ * );
+ * console.log(chart.totals.shots, chart.totals.made, chart.layers.map((layer) => layer.kind).join(" "));
+ * console.log(chart.draw().startsWith("<svg"), chart.table().includes("Restricted area"));
+ * // 4 3 zones points points text
+ * // true true
+ * ```
+ */
+export declare function nbaShotChart(shots: readonly NbaShot[], options?: NbaShotOptions): Chart<NbaTotals> & {
+    key: KeyItem[];
+};
+/** Per-team totals of shots, goals and expected goals. */
+export declare function teamTotals(rows: readonly {
+    x?: number | null;
+    y?: number | null;
+    outcome?: string;
+    team?: string;
+    value?: number | null;
+}[]): Record<string, {
+    shots: number;
+    goals: number;
+    xg: number | null;
+}>;
+/**
+ * A shot map for the NHL from play-by-play shots: each shot a mark (a goal a star, a save an open circle, a miss an open x, a block an open
+ * triangle) sized by its chance of scoring, with an optional count of the shots into the slot zones or hexagons, a legend, a key and a table.
+ * With `fold` the shots at the left end are turned a half turn, so that every shot is at the right end.
+ * @example
+ * ```ts
+ * import { nhlShotMap } from "@johnmorrisdotca/kyogijo-stadiums/charts";
+ * const chart = nhlShotMap(
+ *   [
+ *     { x: 75, y: 4, outcome: "goal", xg: 0.31 },
+ *     { x: -60, y: -12, outcome: "saved", xg: 0.07 },
+ *     { x: 40, y: 20, outcome: "missed", xg: 0.03 },
+ *   ],
+ *   { fold: true, zones: true },
+ * );
+ * console.log(chart.totals.shots, chart.totals.goals, chart.totals.xg);
+ * console.log(chart.layers.map((layer) => layer.id).join(" "));
+ * // 3 1 0.41
+ * // zones shots key-marks key-text
+ * ```
+ */
+export declare function nhlShotMap(shots: readonly NhlShot[], options?: NhlShotOptions): Chart<NhlTotals> & {
+    key: KeyItem[];
+};
+/**
+ * A pass chart for the NFL from tracking data: where each pass came down as a mark (a completion filled, an incompletion open, a touchdown a
+ * star, an interception an x), the line of scrimmage, and the pass grid (short and deep by left, middle and right) coloured by completion
+ * percentage with the air yards of each pass in its table. The offence goes to the right whichever way `direction` says it went in the data.
+ * @example
+ * ```ts
+ * import { nflPassChart } from "@johnmorrisdotca/kyogijo-stadiums/charts";
+ * const chart = nflPassChart(
+ *   [
+ *     { x: 72, y: 26, outcome: "complete" },
+ *     { x: 88, y: 14, outcome: "incomplete" },
+ *     { x: 104, y: 30, outcome: "touchdown" },
+ *   ],
+ *   { los: 65, minPasses: 1 },
+ * );
+ * console.log(chart.totals.passes, chart.totals.complete, chart.totals.airYards);
+ * // 3 2 23
+ * ```
+ */
+export declare function nflPassChart(passes: readonly NflPass[], options?: NflPassOptions): Chart<NflTotals> & {
+    key: KeyItem[];
+};