@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.6.0

package/dist/replay-entry.js

@@ -1,4 +1,6 @@
 // Replay: tracking data over time on a surface. The frame, the clock and the pure functions between them; the controls and the animation
 // are in the mount (`mountKyogijo(...).replay(...)`) and in `<kyogijo-field>`.
 export { activeEvents, describeEvent, drawFrame, eventsBetween, interpolate, possession, replayClock, replayEvents, replayInfo, replayLayers, replaySnapshot, replaySummary, replayTable, replayTimes, trails } from "./replay.js";
+export { alongPool, distanceAt, progressOf, raceTimeline } from "./pool.replay.js";
+export { formatTime, parseTime } from "./pool.race.js";
 export { REPLAY_SPEEDS, REPLAY_SPEED_RANGE, createReplay } from "./replay.control.js";

package/dist/restyle.js

@@ -8,7 +8,7 @@ const LINES = new Set(["ky-line", "ky-red", "ky-blue", "ky-band", "ky-crease"]);
 /** The dashes in the centre line of a rink are lines too, but they are dashes already. */
 const WIDTH = new Set([...LINES, "ky-dash"]);
 /** The classes of marks painted as a fill, which take an opacity. */
-const FILLS = new Set(["ky-fill-line", "ky-red-fill", "ky-blue-fill", "ky-num"]);
+const FILLS = new Set(["ky-fill-line", "ky-wall-line", "ky-red-fill", "ky-blue-fill", "ky-num"]);
 const finitePositive = (value) => typeof value === "number" && Number.isFinite(value) && value > 0;
 /**
  * The look of the lines the options ask for, or `undefined` when they ask for none of it. A width is a multiple of the width the lines are drawn at (`2`,

package/dist/road.draw.js

@@ -1,7 +1,8 @@
 // The road chart, drawn: the two finalists' big round marks with their names, the round names down the middle on a dotted road, each finalist's matches on its side as
 // the round marks of both teams with the score between them, and the group stage as a compact row at the foot. Each size has its own arrangement: `card`, `square` and
 // `phone` stack the finalists over the rounds; `wide` puts them at the two ends. Nothing is measured in a browser: type is set by estimates (`textWidth`).
-import { safeColour, safeLogo } from "./colour.js";
+import { safeColour } from "./colour.js";
+import { safeLogo } from "./logo.js";
 import { safeClass } from "./common.js";
 import { el, esc, num } from "./format.js";
 import { KYOGIJO_MARK_STYLE, roundMarkup } from "./mark.js";
@@ -45,7 +46,7 @@ export function drawRoad(model, o, gid) {
         cx,
         cy,
         r,
-        href: safeLogo(team.logo),
+        href: safeLogo(team.logo, { color: team.color, accent: team.textColor, initials: codeOf(team).slice(0, 3), theme }),
         fit: team.markFit === "contain" ? "contain" : undefined,
         initials: codeOf(team).slice(0, 3),
         color: safeColour(team.color),

package/dist/road.js

@@ -2,6 +2,7 @@
 // them, the rounds named down the middle, and the group stage as a compact row at the foot. The idea is that of the "road to the final" graphics that sports sites post
 // for a World Cup or a Stanley Cup; the arrangement, the type and the code are this package's own, and no one's artwork is used: the marks are the caller's flags and
 // logos, or the team's initials on its colour.
+import { withEmblems } from "./emblems-source.js";
 import { hash } from "./format.js";
 import { safeClass } from "./common.js";
 import { drawRoad } from "./road.draw.js";
@@ -46,7 +47,7 @@ export function roadToFinal(finalists, options = {}) {
         check(merged);
         const m = readModel(finalists, merged);
         const gid = safeClass(merged.id).replace(/ /g, "-") || `kr-${hash(JSON.stringify([finalists, merged, VERSION]))}`;
-        return drawRoad(m, merged, gid);
+        return withEmblems(merged.emblems, () => drawRoad(m, merged, gid));
     };
     return {
         options: { ...options },

package/dist/road.types.d.ts

@@ -1,3 +1,4 @@
+import type { EmblemRenderer } from "./emblems-source.ts";
 import type { Language, Team } from "./types.ts";
 /** A match's score from the finalist's side: `[for, against]` (numbers, or text such as a series' `4`), or one text, `"4-2"`, that is split at its dash. */
 export type RoadScore = readonly [number | string, number | string] | string;
@@ -48,6 +49,8 @@ export interface RoadOptions {
     language?: Language;
     /** A prefix for the ids inside the drawing. Made from the chart when missing, so that two charts on a page do not share ids. */
     id?: string;
+    /** A renderer of ready-made emblems for this chart alone, so that a finalist's `logo` may be an emblem's id. Over the one the page plugged in with `useEmblems`. */
+    emblems?: EmblemRenderer;
     /** The tournament, set large at the top. "Road to the final" when missing. */
     title?: string;
     /** The line under it. "Road to the final" when a `title` is given. */

package/dist/rules.d.ts

@@ -0,0 +1,138 @@
+import { type Attacking, type Frame, type SurfaceSize } from "./frames.ts";
+import "./frames.providers.ts";
+import "./surfaces/soccer-providers.ts";
+import { type Park } from "./parks.ts";
+import type { Language, Sport, SurfaceOptions } from "./types.ts";
+export { RULE_IDS } from "./rules.types.ts";
+export type { RuleId } from "./rules.types.ts";
+/** A place: `[x, y]` or `{ x, y }`. */
+export type PlaceLike = readonly [number, number] | {
+    readonly x: number;
+    readonly y: number;
+};
+/** What `zoneAt` and the predicates take besides the point: the surface's own options (the league, the season, the park, the pitch) and the frame the point is in. */
+export interface ZoneOptions extends Partial<Pick<SurfaceOptions, "league" | "year" | "pitch" | "park" | "fence" | "units" | "sheet" | "net" | "field" | "pool" | "athletics" | "skating" | "language">> {
+    /** The frame the point is in: the name of a frame (`nhl-api`, `opta`), a frame, or nothing for the drawing's own (feet, or `units`). */
+    frame?: Frame | string;
+    /** The size of the surface when the frame is a variable one, in place of the drawing's own. */
+    size?: SurfaceSize;
+    /** The end the point's team attacks, as the surface is drawn wide; `left` turns the numbers a half turn so that the team attacks right. */
+    attacking?: Attacking;
+}
+/** What the rules say of a point. */
+export interface ZoneAnswer {
+    sport: Sport;
+    /** The point on the surface, in feet in the drawing's wide frame, the team attacking the right. */
+    at: [number, number];
+    /** True when the point is on the surface, or on its edge. Off it, `zone`, `subzone` and `zones` are empty (a ballpark is the exception: its foul ground and the stands beyond the fence are zones). */
+    inBounds: boolean;
+    /** The zone the point is in: one of a partition of the surface, such as `offensive-zone`. */
+    zone: string | undefined;
+    /** The finer area in the zone, when there is one: `crease`, `paint`, `six-yard-box`, `warning-track`. */
+    subzone: string | undefined;
+    /** Every id that holds, the zone and the subzone first. */
+    zones: string[];
+    /** The zone of each of the package's zone sets for the sport (`ZONE_SETS`) that the point is in. */
+    sets: Record<string, string>;
+    /** The name of each id in `zones`, in the language asked for. */
+    names: Record<string, string>;
+}
+/** The wall height at a bearing: the stretch of the park's fence that covers it in the season, in feet, or `null` where the park's data holds none. */
+export declare function wallHeightAt(park: Park, angle: number, year?: number): number | null;
+/**
+ * Where a point lies by the rules of a sport: the zone, the area in it and every other area that holds, each by id and name. Hockey answers in the
+ * offensive, neutral and defensive zones with the crease, the trapezoid, the slot, the face-off circles and behind the goal line; basketball in the
+ * frontcourt and backcourt with the restricted area, the paint, the mid-range, the corner threes and the arc; soccer in thirds with the six-yard box,
+ * the penalty area, the D, the half-spaces and the wings; baseball in the infield, the outfield, foul territory, the warning track and over the
+ * wall by the park's own fence; football in the end zones, the halves, the red zone and between the hashes. Every other sport answers in its zone sets.
+ * @example
+ * ```ts
+ * import { zoneAt } from "@johnmorrisdotca/kyogijo-stadiums/zones";
+ * // The NHL API's (69, 22) is the face-off dot in the right end zone: the offensive zone, inside a face-off circle.
+ * const dot = zoneAt("nhl", [69, 22], { frame: "nhl-api" });
+ * console.log(dot.zone, dot.subzone, dot.zones.includes("faceoff-circle"));
+ * // offensive-zone faceoff-circle true
+ * ```
+ */
+export declare function zoneAt(sport: Sport, point: PlaceLike, options?: ZoneOptions): ZoneAnswer;
+/** `zoneAt` for a place already on the surface: feet in the drawing's wide frame, the team attacking the right. What a drawing's click is asked with (pointer.ts). */
+export declare function zoneAtSurface(sport: Sport, at: readonly [number, number], options?: ZoneOptions): ZoneAnswer;
+/**
+ * A function from a place on the surface (feet, the drawing's wide frame, the team attacking the right) to the id of the finest zone it lies in: what a data
+ * layer's marks carry as `data-zone`. Built once for the options of a drawing; `undefined` where the sport has no zone there.
+ */
+export declare function zoneResolver(sport: Sport, options?: ZoneOptions): (x: number, y: number) => string | undefined;
+/**
+ * The name of a zone id in a language: the rules engine's own ids have words in both; any other id (a zone set's) comes back as it is. A court of `league: "fiba"` has the words of FIBA's rule book, which the
+ * Japan Basketball Association follows: the restricted area is the no-charge semicircle (ノーチャージセミサークル); in the NBA and the leagues that follow its words it is the restricted area (リストリクテッドエリア).
+ */
+export declare const zoneName: (id: string, language?: Language, league?: string) => string;
+/** True when a shot from the place would count three: beyond the three-point line (the arc, or past the straight lines at the sidelines), at the basket the team attacks. */
+export declare const isThreePointer: (point: PlaceLike, options?: ZoneOptions) => boolean;
+/** True when the place is in the paint (the free-throw lane, the key), outside the restricted area. */
+export declare const inPaint: (point: PlaceLike, options?: ZoneOptions) => boolean;
+/** True when the place is in the restricted area under the basket. */
+export declare const inRestrictedArea: (point: PlaceLike, options?: ZoneOptions) => boolean;
+/** True when the place is in the slot (the package's definition: the inner and outer slot in front of the net, between the face-off circles), at either end. */
+export declare const inSlot: (point: PlaceLike, options?: ZoneOptions) => boolean;
+/** True when the place is in a goal crease. */
+export declare const inCrease: (point: PlaceLike, options?: ZoneOptions) => boolean;
+/** True when the place is in a penalty area, at the end the team attacks or the one it defends. */
+export declare const inPenaltyArea: (point: PlaceLike, options?: ZoneOptions) => boolean;
+/** True when the place is in a goal area (the six-yard box), at either end. */
+export declare const inSixYardBox: (point: PlaceLike, options?: ZoneOptions) => boolean;
+/** True when the place is in the red zone: inside the opponent's 20-yard line. */
+export declare const inRedZone: (point: PlaceLike, options?: ZoneOptions) => boolean;
+/** True when the place is between the hash marks. */
+export declare const betweenHashes: (point: PlaceLike, options?: ZoneOptions) => boolean;
+/** True when the place is in fair territory: between the foul lines, which are fair themselves. */
+export declare const isFair: (point: PlaceLike, options?: ZoneOptions) => boolean;
+/** True when the place, in fair territory, lies beyond the park's fence: where a ball came down over the wall. `park` is a key of `PARKS`. */
+export declare const overWall: (point: PlaceLike, options?: ZoneOptions) => boolean;
+/** True when the place is on the warning track. */
+export declare const onWarningTrack: (point: PlaceLike, options?: ZoneOptions) => boolean;
+/** What a home-run decision rests on. */
+export interface HomeRunVerdict {
+    /** True: a home run. False: in play or foul. `undefined`: it cannot be told, because the ball was over the fence and its height was given but the park holds no wall height there. */
+    homeRun: boolean | undefined;
+    /** The place is in fair territory. */
+    fair: boolean;
+    /** How far from home plate, and the fence's distance in that direction (at the bearing), in feet. */
+    distance: number;
+    fence: number;
+    /** The bearing from dead centre, in degrees (negative to left field). */
+    angle: number;
+    /** The wall's height at the bearing in feet, or `null` where the park's data holds none. */
+    wall: number | null;
+    /** True when the park has wall heights at all; `isHomeRun` reports it so that a caller can say the data is missing. */
+    wallData: boolean;
+    /** Why, in a word: `foul`, `short` (the ball came down inside the fence), `over` (beyond the fence), `cleared` or `struck-wall` (the given height did not clear the wall), `unknown-wall`. */
+    reason: "foul" | "short" | "over" | "cleared" | "struck-wall" | "unknown-wall";
+}
+/** What a caller can give about the ball. */
+export interface HomeRunOptions extends ZoneOptions {
+    /** The height of the ball in feet as it crossed the fence's line. Without it, a ball that came down beyond the fence in fair territory is a home run. */
+    height?: number;
+}
+/**
+ * The ballparks whose wall heights the package holds nowhere in their fence: of the 94 parks, the 35 whose article gives heights have them for some stretch,
+ * and for the rest the height is not known here, so a decision that needs it is undecided (`homeRun: undefined`), never guessed.
+ */
+export declare const PARKS_WITHOUT_WALL_HEIGHTS: readonly string[];
+/**
+ * Whether a ball is a home run, from the park's own fence: the fence's distance at the bearing and, when the height of the ball is given, the wall's height there
+ * (`wall` data of the park: the stretches of fence with their heights). A ball in fair territory that came down beyond the fence is a home run; one that was
+ * lower than the wall where it crossed struck the wall and is in play. Where the park holds no height for the bearing the answer to a question that needs it
+ * is `homeRun: undefined`, and `wallData` says whether the park has any heights at all. `park` is a key of `PARKS` (or a park); the place is in the frame of `options.frame`
+ * (`retrosheet` and `mlbam` are the usual) or the drawing's own.
+ * @example
+ * ```ts
+ * import { homeRun } from "@johnmorrisdotca/kyogijo-stadiums/zones";
+ * // Fenway Park's Green Monster is 37 feet 2 inches high, 310 feet down the line in left.
+ * console.log(homeRun("fenway-park", [-250, 250], { frame: "retrosheet", height: 30 }).reason, homeRun("fenway-park", [-250, 250], { frame: "retrosheet", height: 40 }).reason);
+ * // struck-wall cleared
+ * ```
+ */
+export declare function homeRun(park: string | Park, point: PlaceLike, options?: HomeRunOptions): HomeRunVerdict;
+/** `homeRun` as a yes or no: `true` for a home run, `false` for foul, in play or the wall struck, `undefined` where the park's wall height is missing and the decision needs it. */
+export declare const isHomeRun: (park: string | Park, point: PlaceLike, options?: HomeRunOptions) => boolean | undefined;