@johnmorrisdotca/kyogijo-stadiums 0.0.0-stage → 0.4.0

package/dist/canvas.js

@@ -0,0 +1,279 @@
+// A scene drawn onto a canvas context: a browser's CanvasRenderingContext2D, an OffscreenCanvas's, or a Node canvas's (@napi-rs/canvas, skia-canvas, node-canvas).
+// Nothing is imported from any of them: the context is typed by the few members this file calls, so any object that has them will do.
+import { rgbOf } from "./colour.js";
+import { apply, boundsOf, IDENTITY, multiply, shapeCommands } from "./scene.path.js";
+import { sceneOf } from "./scene.js";
+/** The colour with an alpha: `rgb(...)` of a hex or rgb colour, or the colour itself when it cannot be read (and the alpha is 1). */
+export function withAlpha(color, alpha) {
+    if (alpha >= 1)
+        return color;
+    const rgba = /^rgba\(\s*(\d+(?:\.\d+)?)[\s,]+(\d+(?:\.\d+)?)[\s,]+(\d+(?:\.\d+)?)[\s,/]+(\d*\.?\d+)\s*\)$/i.exec(color.trim());
+    if (rgba !== null)
+        return `rgba(${rgba[1]},${rgba[2]},${rgba[3]},${Math.round(Number(rgba[4]) * alpha * 1000) / 1000})`;
+    const hex8 = /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i.exec(color.trim());
+    if (hex8 !== null)
+        return `rgba(${parseInt(hex8[1], 16)},${parseInt(hex8[2], 16)},${parseInt(hex8[3], 16)},${Math.round((parseInt(hex8[4], 16) / 255) * alpha * 1000) / 1000})`;
+    const rgb = rgbOf(color);
+    return rgb === undefined ? color : `rgba(${rgb[0]},${rgb[1]},${rgb[2]},${alpha})`;
+}
+const number = (v) => Math.round(v * 1e6) / 1e6;
+function trace(ctx, commands, matrix = IDENTITY) {
+    const at = (x, y) => (matrix === IDENTITY ? [x, y] : apply(matrix, x, y));
+    for (const c of commands) {
+        if (c[0] === "M")
+            ctx.moveTo(...at(c[1], c[2]));
+        else if (c[0] === "L")
+            ctx.lineTo(...at(c[1], c[2]));
+        else if (c[0] === "C")
+            ctx.bezierCurveTo(...at(c[1], c[2]), ...at(c[3], c[4]), ...at(c[5], c[6]));
+        else if (c[0] === "Q")
+            ctx.quadraticCurveTo(...at(c[1], c[2]), ...at(c[3], c[4]));
+        else
+            ctx.closePath();
+    }
+}
+const frame = (ctx, m) => ctx.setTransform(number(m[0]), number(m[1]), number(m[2]), number(m[3]), number(m[4]), number(m[5]));
+/** The width and height the options ask for, and the scale and offset that fit the scene in them. */
+function placement(scene, o) {
+    const { x: vx, y: vy, w, h } = scene.viewBox;
+    let scale = 1;
+    if (o.scale !== undefined)
+        scale = o.scale;
+    else if (o.width !== undefined && o.height !== undefined)
+        scale = Math.min(o.width / w, o.height / h);
+    else if (o.width !== undefined)
+        scale = o.width / w;
+    else if (o.height !== undefined)
+        scale = o.height / h;
+    if (!(scale > 0) || !Number.isFinite(scale))
+        throw new RangeError("The size of a canvas drawing must be more than nothing");
+    const width = o.width !== undefined && o.height !== undefined ? o.width : w * scale;
+    const height = o.width !== undefined && o.height !== undefined ? o.height : h * scale;
+    const ox = (o.x ?? 0) + (width - w * scale) / 2;
+    const oy = (o.y ?? 0) + (height - h * scale) / 2;
+    return { scale, width, height, matrix: [scale, 0, 0, scale, ox - vx * scale, oy - vy * scale] };
+}
+/** Set a fill or stroke style. Returns false when there is nothing to paint. An alpha is written into the colour when it can be, else set on the context. */
+function setPaint(ctx, scene, target, paint, alpha) {
+    ctx.globalAlpha = 1;
+    if (typeof paint === "string") {
+        if (paint === "none")
+            return false;
+        const colour = withAlpha(paint, alpha);
+        ctx[target] = colour;
+        if (alpha < 1 && colour === paint)
+            ctx.globalAlpha = alpha;
+        return true;
+    }
+    if ("gradient" in paint) {
+        const g = scene.gradients.find((one) => one.id === paint.gradient);
+        if (g === undefined || ctx.createLinearGradient === undefined)
+            return false;
+        const gradient = ctx.createLinearGradient(g.x1, g.y1, g.x2, g.y2);
+        for (const stop of g.stops)
+            gradient.addColorStop(stop.offset, withAlpha(stop.color, stop.opacity * alpha));
+        ctx[target] = gradient;
+        return true;
+    }
+    return false;
+}
+function paintShape(ctx, run, shape, matrix) {
+    const s = shape.style;
+    frame(ctx, matrix);
+    const commands = shapeCommands(shape);
+    const filling = s.fill !== "none";
+    const stroking = s.stroke !== "none" && s.strokeWidth > 0;
+    const fill = () => {
+        if (!filling)
+            return;
+        if (typeof s.fill !== "string" && "pattern" in s.fill) {
+            patternFill(ctx, run, shape, matrix, s.fill.pattern);
+            return;
+        }
+        if (!setPaint(ctx, run.scene, "fillStyle", s.fill, s.opacity * s.fillOpacity))
+            return;
+        ctx.beginPath();
+        trace(ctx, commands);
+        ctx.fill(s.fillRule);
+    };
+    const stroke = () => {
+        if (!stroking || !setPaint(ctx, run.scene, "strokeStyle", s.stroke, s.opacity * s.strokeOpacity))
+            return;
+        lineStyle(ctx, s);
+        ctx.beginPath();
+        trace(ctx, commands);
+        ctx.stroke();
+    };
+    if (s.paintOrder === "stroke") {
+        stroke();
+        fill();
+    }
+    else {
+        fill();
+        stroke();
+    }
+}
+function lineStyle(ctx, s) {
+    ctx.lineWidth = s.strokeWidth;
+    ctx.lineJoin = s.lineJoin;
+    ctx.lineCap = s.lineCap;
+    ctx.setLineDash(s.dash === undefined ? [] : [...s.dash]);
+}
+/** A pattern fill: the shape's outline is the clip and the tile's shapes are drawn over its box, tile after tile. */
+function patternFill(ctx, run, shape, matrix, id) {
+    const pattern = run.scene.patterns.find((one) => one.id === id);
+    const box = boundsOf(shape);
+    if (pattern === undefined || box === undefined || !(pattern.width > 0) || !(pattern.height > 0))
+        return;
+    ctx.save();
+    frame(ctx, matrix);
+    ctx.beginPath();
+    trace(ctx, shapeCommands(shape));
+    ctx.clip(shape.style.fillRule);
+    const [i0, i1] = [Math.floor(box.x / pattern.width), Math.ceil((box.x + box.w) / pattern.width)];
+    const [j0, j1] = [Math.floor(box.y / pattern.height), Math.ceil((box.y + box.h) / pattern.height)];
+    for (let j = j0; j < j1; j += 1) {
+        for (let i = i0; i < i1; i += 1) {
+            const tile = multiply(matrix, [1, 0, 0, 1, i * pattern.width, j * pattern.height]);
+            for (const part of pattern.shapes)
+                paintShape(ctx, run, { ...part, style: { ...part.style, opacity: part.style.opacity * shape.style.opacity } }, multiply(tile, part.matrix));
+        }
+    }
+    ctx.restore();
+}
+function paintText(ctx, run, t, matrix) {
+    const s = t.style;
+    // A small size is drawn larger and the drawing taken down by the same amount, so that the engine rasterises the letters at a size it renders well.
+    const k = t.fontSize < 10 ? 10 / t.fontSize : 1;
+    frame(ctx, multiply(matrix, [1 / k, 0, 0, 1 / k, 0, 0]));
+    ctx.font = `${t.fontWeight} ${number(t.fontSize * k)}px ${t.fontFamily}`;
+    ctx.textAlign = t.anchor === "middle" ? "center" : t.anchor === "end" ? "right" : "left";
+    ctx.textBaseline = "alphabetic";
+    if (t.letterSpacing !== 0 || ctx.letterSpacing !== undefined)
+        ctx.letterSpacing = `${number(t.letterSpacing * k)}px`;
+    const x = t.x * k;
+    const y = t.y * k;
+    const fill = () => {
+        if (s.fill !== "none" && setPaint(ctx, run.scene, "fillStyle", s.fill, s.opacity * s.fillOpacity))
+            ctx.fillText(t.text, x, y);
+    };
+    const stroke = () => {
+        if (s.stroke === "none" || !(s.strokeWidth > 0) || !setPaint(ctx, run.scene, "strokeStyle", s.stroke, s.opacity * s.strokeOpacity))
+            return;
+        lineStyle(ctx, { ...s, strokeWidth: s.strokeWidth * k });
+        ctx.strokeText(t.text, x, y);
+    };
+    if (s.paintOrder === "stroke") {
+        stroke();
+        fill();
+    }
+    else {
+        fill();
+        stroke();
+    }
+}
+function paintImage(ctx, run, image, matrix) {
+    if (run.images === undefined || ctx.drawImage === undefined)
+        return;
+    const picture = run.images(image.href);
+    if (picture === undefined || picture === null)
+        return;
+    frame(ctx, matrix);
+    ctx.globalAlpha = image.style.opacity;
+    let { x, y, width, height } = image;
+    const pw = picture.naturalWidth ?? picture.width;
+    const ph = picture.naturalHeight ?? picture.height;
+    // `slice` (a photograph that fills a ground): as small as fills the box, in its middle, cut at the box's edges.
+    if (/slice/.test(image.preserveAspectRatio ?? "") && typeof pw === "number" && typeof ph === "number" && pw > 0 && ph > 0) {
+        const fit = Math.max(width / pw, height / ph);
+        ctx.save();
+        ctx.beginPath();
+        ctx.moveTo(x, y);
+        ctx.lineTo(x + width, y);
+        ctx.lineTo(x + width, y + height);
+        ctx.lineTo(x, y + height);
+        ctx.closePath();
+        ctx.clip();
+        ctx.drawImage(picture, x + (width - pw * fit) / 2, y + (height - ph * fit) / 2, pw * fit, ph * fit);
+        ctx.restore();
+        ctx.globalAlpha = 1;
+        return;
+    }
+    // The default `xMidYMid meet`: the whole picture, as large as the box allows, in its middle. `none` stretches it.
+    if (image.preserveAspectRatio !== "none" && typeof pw === "number" && typeof ph === "number" && pw > 0 && ph > 0) {
+        const fit = Math.min(width / pw, height / ph);
+        x += (width - pw * fit) / 2;
+        y += (height - ph * fit) / 2;
+        width = pw * fit;
+        height = ph * fit;
+    }
+    ctx.drawImage(picture, x, y, width, height);
+    ctx.globalAlpha = 1;
+}
+function paintItem(ctx, run, item) {
+    const matrix = multiply(run.base, item.matrix);
+    if (item.style.filter !== undefined && ctx.filter !== undefined)
+        ctx.filter = item.style.filter;
+    if (item.kind === "text")
+        paintText(ctx, run, item, matrix);
+    else if (item.kind === "image")
+        paintImage(ctx, run, item, matrix);
+    else
+        paintShape(ctx, run, item, matrix);
+    if (item.style.filter !== undefined && ctx.filter !== undefined)
+        ctx.filter = "none";
+}
+/**
+ * Draw a scene (or the options of `drawKyogijo`, or an SVG the package wrote) onto a canvas context. Give a `width` or a `height` in pixels, or a `scale`; the
+ * drawing keeps its shape. Light or dark by `theme`. A team's logo is drawn only if `images` returns a picture for its address.
+ * @example
+ * ```ts
+ * import { drawToCanvas, type CanvasContext } from "@johnmorrisdotca/kyogijo-stadiums/canvas";
+ * // Any object with the context's members will do: this one only counts what is drawn.
+ * const counts: Record<string, number> = {};
+ * const ctx = new Proxy({} as CanvasContext, { get: (_, name: string) => () => void (counts[name] = (counts[name] ?? 0) + 1), set: () => true });
+ * const drawn = drawToCanvas(ctx, { sport: "nhl", id: "rink" }, { width: 800 });
+ * console.log(drawn.width, Math.round(drawn.height), counts.fill > 10);
+ * // 800 374 true
+ * ```
+ */
+export function drawToCanvas(ctx, source, options = {}) {
+    const scene = sceneOf(source, options);
+    const { scale, width, height, matrix } = placement(scene, options);
+    const box = { x: options.x ?? 0, y: options.y ?? 0 };
+    ctx.save();
+    ctx.setTransform(1, 0, 0, 1, 0, 0);
+    if (options.clear === true && ctx.clearRect !== undefined)
+        ctx.clearRect(box.x, box.y, width, height);
+    if (options.background !== undefined && ctx.fillRect !== undefined) {
+        ctx.fillStyle = options.background;
+        ctx.globalAlpha = 1;
+        ctx.fillRect(box.x, box.y, width, height);
+    }
+    const run = { scene, base: matrix, images: options.images };
+    let open = "";
+    for (const item of scene.items) {
+        const key = item.clips.join(",");
+        if (key !== open) {
+            if (open !== "")
+                ctx.restore();
+            open = key;
+            if (key !== "") {
+                ctx.save();
+                for (const index of item.clips) {
+                    const clip = scene.clips[index];
+                    frame(ctx, multiply(matrix, clip.matrix));
+                    ctx.beginPath();
+                    for (const shape of clip.shapes)
+                        trace(ctx, shapeCommands(shape), shape.matrix);
+                    ctx.clip();
+                }
+            }
+        }
+        paintItem(ctx, run, item);
+    }
+    if (open !== "")
+        ctx.restore();
+    ctx.restore();
+    return { width, height, scale };
+}

package/dist/charts-entry.d.ts

@@ -0,0 +1,10 @@
+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 { 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 { 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

@@ -0,0 +1,8 @@
+// The ready-made charts: shot charts, shot maps, spray charts and pass charts built on the data layers, and the road to a final.
+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 { passNetwork } from "./charts.network.js";
+export { ROAD_SIZES, roadToFinal } from "./road.js";
+export { KYOGIJO_ROAD_STYLE } from "./road.style.js";

package/dist/charts.baseball.d.ts

@@ -0,0 +1,30 @@
+import type { Ball, Chart, KeyItem, MlbSprayOptions, MlbTotals } from "./charts.types.ts";
+/** A ball's type as one of the five words of the chart, from the words of Statcast's `events` (`home_run`, `field_out`) and the usual short forms; any other word is kept, in lower case. */
+export declare function ballType(type: string | undefined): string | undefined;
+/**
+ * A spray chart for baseball from batted-ball data: where each ball came down, on the ballpark of that season (`park` and `year`, past parks
+ * included, each with the fence it had then), each hit type in its own mark (a single a small circle, a double a diamond, a triple a triangle,
+ * a home run a star, an out an open circle), the balls that came down beyond the fence drawn beyond it, and if asked the spray zones (pull,
+ * centre and opposite by infield and outfield, by the side the batter bats from). Balls come as Statcast's `hc_x` and `hc_y` (`mlbam`), as feet
+ * from home plate (`retrosheet`) or as Retrosheet's hit-location codes.
+ * @example
+ * ```ts
+ * import { mlbSprayChart } from "@johnmorrisdotca/kyogijo-stadiums/charts";
+ * const chart = mlbSprayChart(
+ *   [
+ *     { x: 125.4, y: 90, type: "single" },
+ *     { x: 60, y: 60, type: "home_run" },
+ *     { x: 150, y: 120, type: "field_out" },
+ *     { zone: "8D", type: "double" },
+ *   ],
+ *   { park: "polo-grounds", year: 1915, bats: "R", zones: true },
+ * );
+ * console.log(chart.totals.balls, chart.totals.types["home run"], chart.options.park, chart.options.year);
+ * console.log(chart.draw().includes("Polo Grounds"));
+ * // 4 1 polo-grounds 1915
+ * // true
+ * ```
+ */
+export declare function mlbSprayChart(balls: readonly Ball[], options?: MlbSprayOptions): Chart<MlbTotals> & {
+    key: KeyItem[];
+};

package/dist/charts.baseball.js

@@ -0,0 +1,152 @@
+// The spray chart: balls in play on the ballpark of their season, each hit type in its own mark, with the balls that cleared the fence drawn
+// beyond it and, if asked, the spray zones. Written for this package: the spray angle and the Gameday pixels are documented in
+// docs/sources.md (the `mlbam` frame); the code of GeomMLBStadiums (GPL), which draws the same kind of chart, was not read.
+import { fenceAt } from "./geometry.js";
+import { convert } from "./frames.js";
+import { zoneToPoint } from "./frames.providers.js";
+import { outlineOf } from "./outline.js";
+import { fenceFor, parkById } from "./parks.js";
+import { MLB } from "./geometry.js";
+import { fill } from "./strings.js";
+import { assemble, clean, countOutcomes, describeCounts, drawingOptions, frameOf, fromOf, hasPlace, keyItems, keyLayers, languageOf, placed, wordsOf, zoneTotals } from "./charts.js";
+/** The look of each hit type: a shape and a size as well as a fill, so that a type is never told by colour alone. */
+const LOOKS = {
+    single: { scale: 0.9 },
+    double: { shape: "diamond", scale: 1.15 },
+    triple: { shape: "triangle", scale: 1.25 },
+    "home run": { shape: "star", scale: 1.55 },
+    out: { hollow: true, scale: 0.9 },
+};
+const ORDER = ["single", "double", "triple", "home run", "out"];
+const HITS = ["single", "double", "triple", "home run"];
+/** A ball's type as one of the five words of the chart, from the words of Statcast's `events` (`home_run`, `field_out`) and the usual short forms; any other word is kept, in lower case. */
+export function ballType(type) {
+    if (typeof type !== "string" || type.trim() === "")
+        return undefined;
+    const key = type.trim().toLowerCase().replace(/[_-]+/g, " ");
+    const exact = { single: "single", "1b": "single", double: "double", "2b": "double", triple: "triple", "3b": "triple", "home run": "home run", homer: "home run", hr: "home run", out: "out" };
+    if (Object.prototype.hasOwnProperty.call(exact, key))
+        return exact[key];
+    // Every way of being put out (a flyout, a groundout, a double play, a fielder's choice, a sacrifice) is an out.
+    return /out|play|sac|fielder|choice/.test(key) ? "out" : key;
+}
+/**
+ * A spray chart for baseball from batted-ball data: where each ball came down, on the ballpark of that season (`park` and `year`, past parks
+ * included, each with the fence it had then), each hit type in its own mark (a single a small circle, a double a diamond, a triple a triangle,
+ * a home run a star, an out an open circle), the balls that came down beyond the fence drawn beyond it, and if asked the spray zones (pull,
+ * centre and opposite by infield and outfield, by the side the batter bats from). Balls come as Statcast's `hc_x` and `hc_y` (`mlbam`), as feet
+ * from home plate (`retrosheet`) or as Retrosheet's hit-location codes.
+ * @example
+ * ```ts
+ * import { mlbSprayChart } from "@johnmorrisdotca/kyogijo-stadiums/charts";
+ * const chart = mlbSprayChart(
+ *   [
+ *     { x: 125.4, y: 90, type: "single" },
+ *     { x: 60, y: 60, type: "home_run" },
+ *     { x: 150, y: 120, type: "field_out" },
+ *     { zone: "8D", type: "double" },
+ *   ],
+ *   { park: "polo-grounds", year: 1915, bats: "R", zones: true },
+ * );
+ * console.log(chart.totals.balls, chart.totals.types["home run"], chart.options.park, chart.options.year);
+ * console.log(chart.draw().includes("Polo Grounds"));
+ * // 4 1 polo-grounds 1915
+ * // true
+ * ```
+ */
+export function mlbSprayChart(balls, options = {}) {
+    if (!Array.isArray(balls))
+        throw new TypeError("balls is a list of balls");
+    const language = languageOf(options);
+    const all = wordsOf(language);
+    const w = all.charts;
+    const frame = frameOf(options.from, "mlbam");
+    const park = options.park === undefined ? undefined : parkById(options.park);
+    if (options.park !== undefined && options.park !== "generic" && park === undefined)
+        throw new RangeError(`Unknown park "${options.park}": use a key of PARKS, such as "fenway-park"`);
+    const margin = typeof options.margin === "number" && options.margin >= 0 ? options.margin : 40;
+    const o = drawingOptions("mlb", options, w.titleMlb, { margin, ...(options.park === undefined ? {} : { park: options.park }), ...(options.year === undefined ? {} : { year: options.year }) });
+    const where = { from: fromOf(options.from, frame) };
+    // A ball given by its Retrosheet zone is put at the zone's centre, in the frame of the chart.
+    const toFrame = frame.name === "retrosheet" ? undefined : convert("retrosheet", frame);
+    const rows = balls.map((b) => {
+        let { x, y } = b;
+        if ((x === undefined || x === null || y === undefined || y === null) && typeof b.zone === "string") {
+            const at = zoneToPoint(b.zone);
+            if (at !== undefined)
+                [x, y] = toFrame === undefined ? at : toFrame([at])[0];
+        }
+        return clean({ x: x ?? null, y: y ?? null, outcome: ballType(b.type), value: b.value, team: b.team, title: b.title });
+    });
+    const { counts, placed: count, skipped } = countOutcomes(rows);
+    // The fence of the park in that season, and the balls that came down beyond it: each ball's distance and its angle from dead centre, from the surface's own feet.
+    const fence = fenceFor(park, undefined, options.year);
+    const at = placed(o, where, rows);
+    const beyond = rows.map((row, i) => {
+        const p = at[i];
+        if (p === undefined)
+            return false;
+        const angle = (Math.atan2(p[0], -p[1]) * 180) / Math.PI;
+        return Math.abs(angle) <= 45 && p[1] < 0 && Math.hypot(p[0], p[1]) > fenceAt(fence, angle);
+    });
+    const inside = rows.filter((row, i) => !beyond[i]);
+    const outside = rows.filter((row, i) => beyond[i]);
+    const known = ORDER.filter((k) => counts.has(k));
+    const other = [...counts.keys()].filter((k) => k !== "" && !ORDER.includes(k));
+    const labels = { single: w.single, double: w.double, triple: w.triple, "home run": w.homeRun, out: w.out };
+    const entries = [...known, ...other].map((k) => ({ label: labels[k] ?? k, outcome: k }));
+    const layers = [];
+    let zonesLayer;
+    if (options.zones !== undefined && options.zones !== false) {
+        const statistic = options.statistic ?? "share";
+        const stat = statistic === "count" ? { statistic: "count" } : statistic === "hit-rate" ? { statistic: "rate", statisticName: w.hitRate, success: HITS } : { statistic: "percent" };
+        zonesLayer = clean({
+            kind: "zones",
+            id: "zones",
+            name: w.balls,
+            zones: (options.zones === true ? "baseball-spray" : options.zones),
+            ...where,
+            bats: options.bats,
+            data: rows,
+            ...stat,
+            success: HITS,
+            labels: options.labels === false ? undefined : options.zones === "baseball-retrosheet" ? undefined : { show: ["value"] },
+            ramp: options.ramp ?? "ocean",
+            legend: options.legend === false ? undefined : true,
+        });
+        layers.push(zonesLayer);
+    }
+    const style = { outcomes: LOOKS, scale: 0.8, opacity: 0.9 };
+    if (options.marks !== false) {
+        const description = describeCounts(entries, counts, all);
+        layers.push(clean({ kind: "points", id: "balls", name: w.balls, description: description === "" ? undefined : description, ...where, data: inside, style }));
+        if (outside.length > 0) {
+            // Over the ground round the fence, held on the drawing, with a note of how many.
+            const { box } = outlineOf(o);
+            const hold = margin - 6;
+            layers.push({
+                kind: "points",
+                id: "beyond",
+                name: w.ballsBeyond,
+                description: fill(w.beyondNote, { n: outside.length }),
+                ...where,
+                data: outside,
+                style,
+                clip: "none",
+                limits: { x: [box.x - hold, box.x + box.w + hold], y: [box.y - hold, box.y + box.h + MLB.backstop] },
+            });
+        }
+    }
+    // The key goes behind home plate, where no ball comes down.
+    if (options.key !== false)
+        layers.push(...keyLayers(o, entries, LOOKS, all, [], { y: MLB.backstop * 0.5 }));
+    const types = {};
+    for (const k of [...known, ...other])
+        types[k] = counts.get(k) ?? 0;
+    const totals = { balls: count, types, beyondFence: outside.filter(hasPlace).length, skipped, zones: zonesLayer === undefined ? [] : zoneTotals(o, zonesLayer) };
+    const list = entries.filter((e) => counts.has(e.outcome ?? "")).map((e) => fill(all.layers.item, { name: e.label, n: counts.get(e.outcome ?? "") ?? 0 })).join(all.layers.listSep);
+    const summary = [fill(w.sumMlb, { balls: count, list }), outside.length > 0 ? fill(w.beyondNote, { n: outside.length }) : ""].filter((s) => s !== "").join(all.said.gap);
+    const chart = assemble(o, layers, { title: w.titleMlb, summary, totals });
+    chart.key = keyItems(entries, LOOKS);
+    return chart;
+}

package/dist/charts.curling.d.ts

@@ -0,0 +1,52 @@
+import type { CurlingOptions, CurlingStone, CurlingTotals, Chart, KeyItem } from "./charts.types.ts";
+/** The colours of the two teams' stones, the handles' colours of a game: red and yellow. */
+export declare const CURLING_COLORS: {
+    readonly home: "#cf2e2e";
+    readonly away: "#f2c230";
+};
+/**
+ * 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 declare function curlingScore(stones: readonly CurlingStone[], options?: {
+    units?: CurlingOptions["units"];
+    width?: number;
+}): CurlingTotals;
+/**
+ * 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 declare function curlingStones(stones: readonly CurlingStone[], options?: CurlingOptions): Chart<CurlingTotals> & {
+    key: KeyItem[];
+};