@johnmorrisdotca/kyogijo-stadiums 0.5.0 → 0.6.0

package/dist/pool.js

@@ -30,7 +30,7 @@ export function commonOf(style) {
     const seed = style.seed === undefined ? 1 : Math.trunc(num(style.seed, "The pool's seed", -1e9, 1e9));
     return { look, deck, seed };
 }
-/** The colour of rope `i` of `n + 1`: green outside, yellow round the middle, blue between (CR 16.1.7.1 for eight lanes; 16.2.7.1.2 for ten). */
+/** The colour of rope `i` of `n + 1`: green outside, yellow round the middle, blue between (Part Two 15.7.6.1 and 15.7.6.3 for eight lanes; 15.7.6.2 for ten). */
 export function ropeColour(i, lanes) {
     if (i === 0 || i === lanes)
         return "green";
@@ -49,7 +49,7 @@ export function laneWidths(course, lanes, temporary) {
 /** The lanes and the ropes of a pool of this width, from the top. */
 export function lanesOf(width, lanes, space) {
     const lane = SWIMMING.lane;
-    // From the bottom wall: the ropes at the edges of the lanes. Ten lanes in the permanent pool: the end ropes 0.1 m from the walls, the others 2.5 m apart from 2.5 m, so that the markings stay 2.5 m apart (CR 16.2.15).
+    // From the bottom wall: the ropes at the edges of the lanes. Ten lanes in the permanent pool: the end ropes 0.1 m from the walls, the others 2.5 m apart from 2.5 m, so that the markings stay 2.5 m apart (Part Two 15.13.2).
     const fromBottom = [];
     for (let k = 0; k <= lanes; k += 1)
         fromBottom.push(lanes === 10 && width === SWIMMING_WIDTHS.permanent ? (k === 0 ? space : k === 10 ? width - space : k * lane) : space + k * lane);
@@ -64,7 +64,7 @@ export function lanesOf(width, lanes, space) {
 }
 /**
  * The swimming pool the options ask for: `pool.course` (`long`, 50 m, or `short`, 25 m) and `pool.lanes` (8 by default). The width is the rules' for that many lanes: 25 m for eight in a 50 m
- * pool (CR 16.2.6.2), 25 m for ten with lanes 0 and 9 of 2.4 m, or 26 m for a temporary pool (CR 16.2.6.3), and lanes of 2.5 m with spaces of 0.5 m for the other pools.
+ * pool (Part Two 15.6.1), 25 m for ten with lanes 0 and 9 of 2.4 m (Part Two 15.6.2.1), or 26 m for a temporary pool (Part Two 15.6.2.2), and lanes of 2.5 m with spaces of 0.5 m for the other pools.
  * @throws RangeError for a lane count that is not 1 to 10, @throws Error for an unknown look.
  */
 export function swimPlan(o, defaults = {}) {
@@ -101,7 +101,7 @@ export function swimPlan(o, defaults = {}) {
         plan.race = racePlan(style.race, lanes.map((l) => l.number), { splitEvery: course === "long" ? 50 : 25, length });
     return plan;
 }
-/** The water polo field the options ask for: 25 by 20 m (CR 18.1.2). */
+/** The water polo field the options ask for: 25 by 20 m (Part Six 20.2.2). */
 export function poloPlan(o) {
     const style = o.pool ?? {};
     const table = style.table === "top" ? "top" : "bottom";
@@ -118,7 +118,7 @@ const BOARDS = {
 };
 /**
  * The diving well the options ask for. The springboards (1 m and 3 m, `pool.boards` of each, 2 by default so that a synchronised pair stands side by side) stand along the left wall, 3 m boards outside, each the preferred
- * distance (Appendix 2, B and C) from the wall and from the next; the platforms (5, 7.5 and 10 m by default) stand towards the right wall, the tallest the distance B from it and each lower one the distance C of the
+ * distance (Part Four, Appendix 2, B and C) from the wall and from the next; the platforms (5, 7.5 and 10 m by default) stand towards the right wall, the tallest the distance B from it and each lower one the distance C of the
  * platform above it from that one. The well is 25 m across, wider if the boards need more room than that.
  * @throws RangeError for a platform the rules do not have or a count of boards that is not 1 to 4.
  */
@@ -179,7 +179,7 @@ export function divePlan(o) {
     const behind = Math.max(0, ...all.map((b) => b.length - b.x));
     return { sport: "diving", ...commonOf(style), length: DIVING.well.length, width, boards: all, behind };
 }
-/** The artistic swimming area the options ask for: 30 by 20 m for the Olympic Games and the World Championships, or the least, 25 by 15 m with a 12 by 12 m deep part (CR 27.2.2, 27.1.2). */
+/** The artistic swimming area the options ask for: 30 by 20 m for the Olympic Games and the World Championships, or the least, 25 by 15 m with a 12 by 12 m deep part (Part Seven 12.2.2, 12.1.1). */
 export function artisticPlan(o) {
     const style = o.pool ?? {};
     const area = style.area === "minimum" ? "minimum" : "olympic";
@@ -237,7 +237,7 @@ export function reachOf(plan) {
 const ROW = 125;
 /**
  * The pools of a hall (`pool.venue`) laid out to scale. A pool with an `x` and a `y` stands there; the others are set in rows, left to right, each `apart` metres (10, the distance the rules prefer between
- * a swimming pool and a diving well, CR 16.2.17; never less than the 8 they require) from the one before, and a new row when a row would be longer than 125 m.
+ * a swimming pool and a diving well, Part Two 15.15.1; never less than the 8 they require) from the one before, and a new row when a row would be longer than 125 m.
  * @throws RangeError when two pools are nearer each other than `apart`, for the pools given places.
  */
 export function venueLayout(style) {

package/dist/pool.labels.js

@@ -1,7 +1,8 @@
 // The data of a race on a pool: who is in each lane (the lane number, the flag, the name, the country's letters), what each swam (the place as a medal, the time, the reaction time, the splits) and the
 // split pace bars in the lanes. Drawn in feet in the frame of a pool lying wide; a pool lying tall turns it with the pool, so that the labels lie along the lanes, and only the numbers in the discs are
 // turned back upright. Nothing here is a rule of the sport: the sizes are ours.
-import { safeColour, safeLogo } from "./colour.js";
+import { safeColour } from "./colour.js";
+import { safeLogo } from "./logo.js";
 import { el, esc, num } from "./format.js";
 import { feet } from "./pool.js";
 import { STATUS_TEXT, formatTime, pacePer100, splitMetres } from "./pool.race.js";

package/dist/ranges.names.js

@@ -72,6 +72,12 @@ export const RANGES = Object.freeze({
         range("javelin-throw", "left"),
         range("water-jump", "left"),
     ]),
+    judo: Object.freeze([range("contest-area", "left"), range("start"), range("half", "left")]),
+    karate: Object.freeze([range("contest-area", "left"), range("start"), range("half", "left")]),
+    kendo: Object.freeze([range("start"), range("half", "left")]),
+    sumo: Object.freeze([range("ring"), range("start"), range("half", "left")]),
+    kyudo: Object.freeze([range("shajo"), range("yamichi"), range("azuchi")]),
+    dojo: Object.freeze([range("kamiza"), range("half", "left")]),
 });
 const isNumber = (value) => typeof value === "number" && Number.isFinite(value);
 /**

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;