@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.6.0

package/dist/budo/tatami.js

@@ -0,0 +1,156 @@
+import { num } from "../format.js";
+import { path } from "../fields.kit.js";
+const EPS = 1e-6;
+const close = (a, b, tol = 1e-4) => Math.abs(a - b) <= tol;
+const r4 = (v) => Math.round(v * 10000) / 10000;
+/** The kind of a piece of a floor laid with mats of a size. */
+export function kindOf(w, h, mat, along) {
+    const long = along === "y" ? h : w;
+    const short = along === "y" ? w : h;
+    if (close(short, mat.width) && close(long, mat.length))
+        return "full";
+    if (close(short, mat.width) && close(long, mat.length / 2))
+        return "half";
+    return "cut";
+}
+/**
+ * Lay a rectangle with mats whose long sides run along `along`, in columns the width of a mat. With `stagger` every second column is set off by half a mat, so that no four
+ * corners meet (the traditional lay); without it the mats make a grid. The floor's ends and sides are cut to fit where its size is not a whole number of mats; a column that is
+ * set off begins and ends with half a mat.
+ */
+export function lay(rect, mat, along, stagger) {
+    const out = [];
+    const acrossLen = along === "y" ? rect.x1 - rect.x0 : rect.y1 - rect.y0;
+    const alongLen = along === "y" ? rect.y1 - rect.y0 : rect.x1 - rect.x0;
+    const columns = Math.max(0, Math.ceil(acrossLen / mat.width - EPS));
+    for (let c = 0; c < columns; c += 1) {
+        const a0 = c * mat.width;
+        const a1 = Math.min(a0 + mat.width, acrossLen);
+        const offset = stagger && c % 2 === 1 ? mat.length / 2 : 0;
+        let b = 0;
+        if (offset > 0) {
+            const e = Math.min(offset, alongLen);
+            push(out, rect, along, a0, a1, 0, e, mat);
+            b = e;
+        }
+        while (b < alongLen - EPS) {
+            const e = Math.min(b + mat.length, alongLen);
+            push(out, rect, along, a0, a1, b, e, mat);
+            b = e;
+        }
+    }
+    return out;
+}
+function push(out, rect, along, a0, a1, b0, b1, mat) {
+    const x0 = along === "y" ? rect.x0 + a0 : rect.x0 + b0;
+    const x1 = along === "y" ? rect.x0 + a1 : rect.x0 + b1;
+    const y0 = along === "y" ? rect.y0 + b0 : rect.y0 + a0;
+    const y1 = along === "y" ? rect.y0 + b1 : rect.y0 + a1;
+    out.push({ x0: r4(x0), y0: r4(y0), x1: r4(x1), y1: r4(y1), kind: kindOf(x1 - x0, y1 - y0, mat, along), along, tone: 1 });
+}
+/** The part of a piece inside a box, and the parts of it outside, each a piece of its own (a mat cut where a colour changes). */
+export function cutBy(piece, box, mat) {
+    const ix0 = Math.max(piece.x0, box.x0);
+    const iy0 = Math.max(piece.y0, box.y0);
+    const ix1 = Math.min(piece.x1, box.x1);
+    const iy1 = Math.min(piece.y1, box.y1);
+    const mk = (x0, y0, x1, y1) => ({ x0: r4(x0), y0: r4(y0), x1: r4(x1), y1: r4(y1), along: piece.along, tone: piece.tone, kind: kindOf(x1 - x0, y1 - y0, mat, piece.along) });
+    if (ix1 - ix0 <= EPS || iy1 - iy0 <= EPS)
+        return { inside: undefined, outside: [piece] };
+    const outside = [];
+    if (iy0 - piece.y0 > EPS)
+        outside.push(mk(piece.x0, piece.y0, piece.x1, iy0));
+    if (piece.y1 - iy1 > EPS)
+        outside.push(mk(piece.x0, iy1, piece.x1, piece.y1));
+    if (ix0 - piece.x0 > EPS)
+        outside.push(mk(piece.x0, iy0, ix0, iy1));
+    if (piece.x1 - ix1 > EPS)
+        outside.push(mk(ix1, iy0, piece.x1, iy1));
+    return { inside: mk(ix0, iy0, ix1, iy1), outside };
+}
+/**
+ * Give every piece the tone of the zone it lies in: the first of `zones` that holds it, else `rest`. A mat that a boundary runs through is cut there, each part
+ * taking its own zone's tone.
+ */
+export function tint(pieces, zones, rest, mat) {
+    let left = pieces.map((p) => ({ ...p, tone: rest }));
+    const out = [];
+    for (const zone of zones) {
+        const next = [];
+        for (const p of left) {
+            const cut = cutBy(p, zone.box, mat);
+            if (cut.inside !== undefined)
+                out.push({ ...cut.inside, tone: zone.tone });
+            next.push(...cut.outside);
+        }
+        left = next;
+    }
+    return [...out, ...left].sort((a, b) => a.y0 - b.y0 || a.x0 - b.x0);
+}
+/** The mats of a checker floor: the tone alternates from one mat to the next, as the squares of a chessboard do. */
+export function checker(pieces, rect, mat) {
+    return pieces.map((p) => {
+        const col = Math.round((p.along === "y" ? p.x0 - rect.x0 : p.y0 - rect.y0) / mat.width);
+        const row = Math.round((p.along === "y" ? p.y0 - rect.y0 : p.x0 - rect.x0) / mat.length);
+        return { ...p, tone: ((col + row) % 2 === 0 ? 1 : 2) };
+    });
+}
+/**
+ * How many points are a corner of four pieces or more: where four mats meet. A floor laid in the traditional way has none. Pieces that only touch along a side are not counted (a T is a point
+ * where one piece's side runs past the corners of two others, not a corner of three).
+ */
+export function fourCorners(pieces) {
+    const count = new Map();
+    const key = (x, y) => `${Math.round(x * 1000)},${Math.round(y * 1000)}`;
+    for (const p of pieces) {
+        for (const [x, y] of [[p.x0, p.y0], [p.x1, p.y0], [p.x0, p.y1], [p.x1, p.y1]])
+            count.set(key(x, y), (count.get(key(x, y)) ?? 0) + 1);
+    }
+    let meets = 0;
+    for (const n of count.values())
+        if (n >= 4)
+            meets += 1;
+    return meets;
+}
+/** The floor's area in square metres. */
+export const areaOf = (pieces) => pieces.reduce((sum, p) => sum + (p.x1 - p.x0) * (p.y1 - p.y0), 0);
+/** The number of mats a floor holds, counted as the mats' own area: a half mat is a half, a cut piece the share of a mat it covers. */
+export const matCount = (pieces, mat) => areaOf(pieces) / (mat.length * mat.width);
+const rectD = (b) => `M${num(b.x0)} ${num(b.y0)}H${num(b.x1)}V${num(b.y1)}H${num(b.x0)}Z`;
+/** The painted areas of a floor of mats: one path for each tone, in the class the look gives it. */
+export function tatamiAreas(id, pieces, classes, feature) {
+    const out = [];
+    for (const tone of [1, 2, 3]) {
+        const of = pieces.filter((p) => p.tone === tone);
+        if (of.length > 0)
+            out.push({ id: `${id}-t${tone}`, feature: feature[tone], cls: classes[tone], d: of.map(rectD).join("") });
+    }
+    return out;
+}
+/** The seams: the outline of every piece, as one line. */
+export function seams(id, pieces, width) {
+    if (pieces.length === 0)
+        return [];
+    return [path(`${id}-seams`, "seams", pieces.map(rectD).join(""), { w: width, cls: "ky-bud-seam", least: 0 })];
+}
+/** The heri (畳縁), the cloth along the two long sides of a traditional mat, as filled strips inside the mat. Cut pieces and the thin ends of a floor have none. */
+export function heri(id, pieces, width, mat) {
+    const strips = [];
+    for (const p of pieces) {
+        if (p.kind === "cut")
+            continue;
+        const w = p.x1 - p.x0;
+        const h = p.y1 - p.y0;
+        if (p.along === "y") {
+            if (w < mat.width * 0.9 || h < mat.length * 0.45)
+                continue;
+            strips.push(rectD({ x0: p.x0, y0: p.y0, x1: p.x0 + width, y1: p.y1 }), rectD({ x0: p.x1 - width, y0: p.y0, x1: p.x1, y1: p.y1 }));
+        }
+        else {
+            if (h < mat.width * 0.9 || w < mat.length * 0.45)
+                continue;
+            strips.push(rectD({ x0: p.x0, y0: p.y0, x1: p.x1, y1: p.y0 + width }), rectD({ x0: p.x0, y0: p.y1 - width, x1: p.x1, y1: p.y1 }));
+        }
+    }
+    return strips.length === 0 ? [] : [{ id: `${id}-heri`, feature: "heri", cls: "ky-bud-heri", d: strips.join("") }];
+}

package/dist/budo/types.d.ts

@@ -0,0 +1,192 @@
+/** The sports of the budō family. */
+export type BudoKind = "judo" | "karate" | "kendo" | "sumo" | "kyudo" | "dojo";
+/** The sides of a hall, as a plan has them: north is the top of the drawing. `top`, `bottom`, `left` and `right` say the same. */
+export type Compass = "north" | "south" | "east" | "west";
+export type Side4 = Compass | "top" | "bottom" | "left" | "right";
+/**
+ * What a budō drawing takes beyond a surface. Every part is optional: a judo contest area is the IJF's of 10 m with a safety area of 4 m, a karate area the WKF's kumite square, a kendo
+ * shiai-jo of 10 m, a dohyō of the Japan Sumo Association and a kyūdōjō of 28 m with five shooters, drawn without any.
+ */
+export interface BudoStyle {
+    /** A named look: the colours of the mats and of the floor. Judo: `yellow-red` (the IJF's own, the default), `yellow-blue`, `blue-grey`, `green-beige` (the traditional tatami), `green-red` (green mats with a red danger zone) and `black-red`. Karate: `blue-red` (the default), `blue-black`, `green-beige`. Kendo: `wood` (the default), `blond`. Sumo: `clay`. Kyūdō: `wood`. Dojo: `green-beige` (the default), `yellow-red`, `yellow-blue`, `blue-grey`, `black-red`, `green-red`. */
+    look?: string;
+    /** Judo and karate: how many competition areas lie side by side, 1 to 6 (1 by default), or `{ across, down }` for a block of them. They are as far apart as the rules ask, the common safety area. */
+    areas?: number | {
+        across: number;
+        down: number;
+    };
+    /** Judo, karate and kendo: the arena floor under the surface. `budokan` is the Nippon Budokan's, an octagon 55 m across the flats (the Budokan's leaflet), with the surface in the middle; it must fit. */
+    hall?: "budokan";
+    /** Judo: the contest area's side, 8 m to 10 m. Kendo: the shiai-jo's side, 9 m to 11 m. In metres. */
+    size?: number;
+    /** Judo: the width of the safety area, 3 m or more (4 m by default). In metres. */
+    safety?: number;
+    /** Judo: the tatami's size. `2x1` (the IJF's, 2 m by 1 m, the default of an IJF area), `1x1` (the half tatami) or `182x91` (the AJJF's own, the default of an AJJF area). */
+    tatami?: "2x1" | "1x1" | "182x91";
+    /** Judo: the tape that marks where the contestants start. On by default for the AJJF's area and the kata area, and for the IJF's (the 2020 rules' blue and white tape). */
+    start?: boolean;
+    /** Judo: a solid platform under the tatami, one metre wider and longer than it. Off by default. */
+    platform?: boolean;
+    /** Judo and karate: the technical table, the officials' seats and the judges, outside the safety area. Off by default. */
+    officials?: boolean;
+    /** Judo: draw the lines of the mats (the seams between them). On by default. */
+    seams?: boolean;
+    /** Judo and dojo: `weave` draws the rice-straw weave of a mat as fine ridges along each mat's long side (they turn a quarter where a mat does), with a faint highlight on the mat edges; `none` leaves the mats plain. A traditional dojo has it by default, a judo area has none. It drops away at the simple detail. */
+    texture?: "weave" | "none";
+    /** Karate: the referee's and the judges' places. On by default. */
+    judges?: boolean;
+    /** Sumo: the height of the clay square in metres, 0.34 to 0.60. 0.55 by default. Seen in 3D. */
+    height?: number;
+    /** Sumo: the four tassels of the roof, in the colours of the four quarters (green east, red south, white west, black north). Off by default. */
+    tassels?: boolean;
+    /** Sumo: the tawara, the shikiri-sen and the sand of the jano-me. On by default. */
+    tawara?: boolean;
+    /** Kyūdō: the number of shooters in a line, 1 to 12 (5 by default). */
+    shooters?: number;
+    /** Kyūdō: the kind of range, `kinteki` (28 m, the default) or `enteki` (60 m); `league` says it too. */
+    range?: "kinteki" | "enteki";
+    /** Kyūdō: the target of each shooter at the azuchi. On by default. */
+    targets?: boolean;
+    /** Kyūdō: the roof of the shajō. On by default. */
+    roof?: boolean;
+}
+/** What each team has scored, as the sport counts it. Every part is optional; what is not given is left out of the board. */
+export interface BudoScore {
+    /** Judo, karate: the number of ippon (judo: 1 ends the contest; the IJF's scoreboard writes 100). */
+    ippon?: number;
+    /** Judo (10 on the scoreboard), karate (2 points). Two waza-ari are ippon in judo. */
+    wazaari?: number;
+    /** Judo (1 on the scoreboard), karate (1 point). */
+    yuko?: number;
+    /** Judo: the shido, three of which are hansoku-make. Karate: the warnings (chui), up to three. */
+    shido?: number;
+    /** Karate: the first unopposed score, senshu (先取). */
+    senshu?: boolean;
+    /** Kendo: the points of the match, each by the target struck: `men`, `kote`, `do` or `tsuki`, or `hansoku` for the point a foul gave the other side. */
+    techniques?: readonly string[];
+    /** Sumo: the kimarite that decided the bout, by its key (`yorikiri`) or its name (寄り切り). Only the winner's. */
+    kimarite?: string;
+}
+/** A door of a dojo: the wall it is in, where along it (0 to 1, the middle by default) and how wide (1.8 m by default). */
+export interface Entrance {
+    wall: Side4;
+    at?: number;
+    width?: number;
+}
+/** A window of a dojo: the wall, where along it (0 to 1, the middle by default) and how wide (1.8 m by default). */
+export interface DojoWindow {
+    wall: Side4;
+    at?: number;
+    width?: number;
+}
+/** The size of a dojo's floor: the mats across and along, or a size with a unit, or the area in jō. */
+export type DojoSize = number | readonly [number, number] | {
+    width?: number;
+    length?: number;
+    unit?: "m" | "ft" | "mat" | "jo";
+    jo?: number;
+};
+/** The ways a dojo's mats are laid. */
+export type DojoPattern = "traditional" | "competition" | "checker" | "border";
+/** One look of a dojo's floor in its history. */
+export interface DojoEra {
+    /** The era's name, as `era` asks for it (`earlier`, `current`). */
+    name: string;
+    nameJa?: string;
+    /** The first and the last year it lasted, `null` where no source gives the year (an era with no years is picked by name, or as the last). */
+    from?: number | null;
+    to?: number | null;
+    look?: string;
+    colours?: DojoColours;
+    pattern?: DojoPattern;
+    areas?: number | {
+        across: number;
+        down: number;
+    };
+    areaSize?: number;
+    outline?: boolean;
+}
+/** The colours a dojo may be given, each a CSS colour. */
+export interface DojoColours {
+    /** The mats. */
+    mat?: string;
+    /** The second tone: the other mats of a `checker` floor, the worn side of a mat, the border of a `border` floor. */
+    alt?: string;
+    /** The border of a `border` floor (a danger zone). */
+    border?: string;
+    /** The heri (畳縁), the cloth edge along a traditional mat's long sides. */
+    heri?: string;
+    /** The wood of the floor outside the mats, and of the walls' base. */
+    floor?: string;
+    /** The walls. */
+    wall?: string;
+}
+/**
+ * A dojo (道場): the floor in mats, laid out as real tatami units, and what stands round it. Every part is optional: 20 jō of traditional mats with the kamiza at the north, no walls.
+ * `dojo()` makes its plan, and `drawKyogijo({ sport: "dojo", dojo })` draws it.
+ */
+export interface DojoSpec {
+    /**
+     * The floor. A number is its area in jō (畳): 8, 12, 20, 50, 100 or 200 give the usual shapes. `[across, along]` is the number of whole mats across the floor and along it
+     * (`[5, 4]` is 20 jō). `{ width, length, unit }` is a size in metres (the default), feet, `mat` (as the array) or `jo`. 20 jō by default.
+     */
+    mats?: DojoSize;
+    /** The area in jō, as `mats: 20` says it. */
+    jo?: number;
+    /** `traditional` (the default): mats laid so that no four corners meet, with a heri along the long sides. `competition`: the same lay, with the contest areas' colours. `checker`: the mats' tones alternate. `border`: a band of another colour round the floor. */
+    pattern?: DojoPattern;
+    /** The colours. A named look in `look` sets all of them. */
+    colours?: DojoColours;
+    colors?: DojoColours;
+    /** A named look: `green-beige` (the default), `yellow-red`, `yellow-blue`, `blue-grey`, `black-red`, `green-red`. */
+    look?: string;
+    /** The wall the kamiza (上座), the seat of honour, is at. North (the top of the drawing) by default. The shōmen is that wall. */
+    kamiza?: Side4;
+    /** The doors. One in the middle of the wall opposite the kamiza by default. */
+    entrances?: readonly Entrance[];
+    /** The walls round the floor. On by default; `false` for the floor alone. */
+    walls?: boolean | {
+        thickness?: number;
+    };
+    /** The windows: a list, or a number of them spread along the long walls. None by default. */
+    windows?: readonly DojoWindow[] | number;
+    /** The shinzen (神前), a shrine at the middle of the kamiza wall. Off by default. */
+    shinzen?: boolean;
+    /** The dojo's name, for the title and the description. */
+    label?: string;
+    labelJa?: string;
+    /** Judo contest areas laid on the floor: 1 to 6 in a row (none by default), or `{ across, down }` for a block (`{ across: 2, down: 2 }` is four), of 8 m with a safety area where they fit. */
+    areas?: number | {
+        across: number;
+        down: number;
+    };
+    /** The side of a contest area laid on the floor, 8 m to 10 m (the IJF's, 8 m by default). In metres. */
+    areaSize?: number;
+    /** A band one mat wide round each contest area in the third colour (the border mats that outline an area on a floor of one colour). Off by default. */
+    outline?: boolean;
+    /** `weave` or `none`: the rice-straw weave of the mats (on by default for the traditional and border lays). */
+    texture?: "weave" | "none";
+    /** The wood round the mats, between them and the walls, in metres (none by default; the Kodokan's main dojo has a polished wood surround). */
+    surround?: number;
+    /** A spectators' balcony above the floor, as `dojoRoom()` gives it (it is not part of the plan's drawing; `crowd` draws the stands): `true` for all four sides, or the sides, depth in metres (3 by default), seat rows (5) and height above the mats (4 m). */
+    balcony?: boolean | {
+        sides?: readonly Side4[];
+        depth?: number;
+        rows?: number;
+        height?: number;
+    };
+    /** The seat of honour's platform: a raised wooden dais at the middle of the kamiza wall (a chair stands on it in the Kodokan's main dojo). Off by default. */
+    dais?: boolean;
+    /** A plain dark vertical banner on the kamiza wall, over the dais or the shrine (a drawing of a banner, never any emblem). Off by default. */
+    banner?: boolean;
+    /**
+     * The history of the floor: the looks it has had, oldest first. Each era names itself and may say the years it lasted (`from` and `to`, both inclusive, `null` where the years are not known),
+     * and any of `look`, `colours`, `pattern`, `areas`, `areaSize` and `outline` it changes. `era` picks one by name; `year` picks the one that holds the year (the first whose years hold it);
+     * with neither, the last (the floor as it is now) is drawn.
+     */
+    eras?: readonly DojoEra[];
+    era?: string;
+    year?: number;
+    /** The mat standard: a league of the `dojo` sport: `chukyoma` (the default), `kyoma`, `edoma`, `danchima` or `judo-2x1`; `league` says it too. */
+    standard?: string;
+}

package/dist/budo/types.js

@@ -0,0 +1,2 @@
+// The types of the budō (武道) surfaces: judo and karate contest areas, the kendo shiai-jo, the sumo dohyō, the kyūdōjō, and a dojo of tatami, and the options that say what is drawn. Plain data only.
+export {};

package/dist/budo-entry.d.ts

@@ -0,0 +1,22 @@
+export { DOJO_STANDARDS, dojo, drawDojo } from "./budo/dojo.api.ts";
+export type { Dojo, Tatami } from "./budo/dojo.api.ts";
+export { DOJO_SIZES, floorOf, shapeOfJo } from "./budo/dojo.ts";
+export { dojoGallery, dojoRoom, ROOM_HEIGHTS } from "./budo/room.ts";
+export type { DojoGallery, DojoRoom, RoomBalcony, RoomBasis, RoomOpening, RoomWall } from "./budo/room.ts";
+export { budoLeague, budoPlan, BUDO_SPORTS, BUDOKAN_ARENA, isBudoSport } from "./budo/plan.ts";
+export type { BudoPlan, MBox, MMark, MRange } from "./budo/plan.ts";
+export { checker, fourCorners, kindOf, lay, matCount, tint } from "./budo/tatami.ts";
+export type { MatSize, Piece, PieceKind } from "./budo/tatami.ts";
+export { TATAMI } from "./budo/judo.ts";
+export { KIMARITE, KIMARITE_COUNT, KIMARITE_OTHERS, kimariteName, kimariteOf } from "./budo/kimarite.ts";
+export type { Kimarite, KimariteGroup } from "./budo/kimarite.ts";
+export { BUDO_LOOKS, lookNames } from "./budo/looks.ts";
+export type { BudoLook } from "./budo/looks.ts";
+export { budoScoreText, budoView } from "./budo.score.ts";
+export type { BudoView } from "./budo.score.ts";
+export { KYOGIJO_BUDO_STYLE } from "./budo.style.ts";
+export { AJJF_CONTEST, BUDO_LEAGUES, DOJO_LEAGUES, ENTEKI, FIK_SHIAI_JO, IJF_CONTEST, IJF_KATA, JSA_DOHYO, JUDO_LEAGUES, KARATE_LEAGUES, KENDO_LEAGUES, KINTEKI, KYUDO_LEAGUES, SUMO_LEAGUES } from "./leagues/budo.ts";
+export type { BudoFigures, BudoLeague, DojoFigures, DojoLeague, JudoFigures, JudoLeague, KarateFigures, KarateLeague, KendoFigures, KendoLeague, KyudoFigures, KyudoLeague, Mat, SumoFigures, SumoLeague } from "./leagues/budo.ts";
+export { HALLS } from "./halls.ts";
+export type { Hall, HallBasis, HallSurface } from "./halls.ts";
+export type { BudoKind, BudoScore, BudoStyle, Compass, DojoColours, DojoEra, DojoPattern, DojoSize, DojoSpec, DojoWindow, Entrance, Side4 } from "./budo/types.ts";

package/dist/budo-entry.js

@@ -0,0 +1,13 @@
+// The budō (武道): judo and karate competition areas, the kendo shiai-jo, the sumo dohyō, the kyūdōjō and the dojo builder, with their plans, the tatami layout, the kimarite, the looks and the stylesheet.
+export { DOJO_STANDARDS, dojo, drawDojo } from "./budo/dojo.api.js";
+export { DOJO_SIZES, floorOf, shapeOfJo } from "./budo/dojo.js";
+export { dojoGallery, dojoRoom, ROOM_HEIGHTS } from "./budo/room.js";
+export { budoLeague, budoPlan, BUDO_SPORTS, BUDOKAN_ARENA, isBudoSport } from "./budo/plan.js";
+export { checker, fourCorners, kindOf, lay, matCount, tint } from "./budo/tatami.js";
+export { TATAMI } from "./budo/judo.js";
+export { KIMARITE, KIMARITE_COUNT, KIMARITE_OTHERS, kimariteName, kimariteOf } from "./budo/kimarite.js";
+export { BUDO_LOOKS, lookNames } from "./budo/looks.js";
+export { budoScoreText, budoView } from "./budo.score.js";
+export { KYOGIJO_BUDO_STYLE } from "./budo.style.js";
+export { AJJF_CONTEST, BUDO_LEAGUES, DOJO_LEAGUES, ENTEKI, FIK_SHIAI_JO, IJF_CONTEST, IJF_KATA, JSA_DOHYO, JUDO_LEAGUES, KARATE_LEAGUES, KENDO_LEAGUES, KINTEKI, KYUDO_LEAGUES, SUMO_LEAGUES } from "./leagues/budo.js";
+export { HALLS } from "./halls.js";

package/dist/budo.board.d.ts

@@ -0,0 +1,28 @@
+import type { BudoView } from "./budo.score.ts";
+import type { TeamView } from "./score.ts";
+import type { PlateSpot } from "./surfaces/surface.ts";
+/** The words of a board. */
+export interface BudoBoardWords {
+    competition?: string;
+    foot?: string;
+    wazaari: string;
+    yuko: string;
+    shido: string;
+    senshu: string;
+    chui: string;
+    kimarite: string;
+    /** The first letter or character of each technique's name, for a kendo point. */
+    techniques: Record<string, string>;
+    /** What the winner's kimarite is called, already in the language. */
+    kimariteName: (key: string) => string;
+}
+type Sport = "judo" | "karate" | "kendo" | "sumo";
+/** A team as the board reads it. */
+export type BoardTeam = TeamView & {
+    budo?: BudoView;
+};
+/** The board as a group centred on the origin. `spot` is the room it has; it takes only what its rows and columns need. */
+export declare function budoBoardMarkup(sport: Sport, spot: PlateSpot, left: BoardTeam, right: BoardTeam, words: BudoBoardWords, o: {
+    parts: boolean;
+}): string;
+export {};

package/dist/budo.board.js

@@ -0,0 +1,81 @@
+// The budō scoreboards: judo's (the waza-ari, the yuko and the shido of each side beside its score), karate's (the points, the senshu and the warnings), kendo's (the techniques of its points, as the
+// letters of their targets) and sumo's (the result and the kimarite). Drawn on the surface, in the frame the eye sees; the caller turns it back when the surface is turned.
+import { el, esc } from "./format.js";
+import { fitLines, textWidth } from "./text.js";
+const text = (x, cy, value, size, cls, extra = {}) => el("text", { class: `ky-text ${cls}`, x, y: cy + size * 0.36, "font-size": size, "text-anchor": "middle", ...extra }, esc(value));
+const fit = (value, room, ceiling) => Math.max(0.1, Math.min(ceiling, room / Math.max(1, textWidth(value))));
+const num = (v) => (v === undefined ? "" : String(v));
+/** The columns of a sport's board, between the name and the total. */
+function columns(sport, w) {
+    switch (sport) {
+        case "judo":
+            return [
+                { head: w.wazaari, width: 1.7, cell: (t) => num(t.budo?.wazaari) },
+                { head: w.yuko, width: 1.3, cell: (t) => num(t.budo?.yuko) },
+                { head: w.shido, width: 1.3, cell: (t) => num(t.budo?.shido) },
+            ];
+        case "karate":
+            return [
+                { head: w.chui, width: 1.3, cell: (t) => num(t.budo?.shido) },
+                { head: w.senshu, width: 1.5, cell: (t) => (t.budo?.senshu === true ? "●" : "") },
+            ];
+        case "kendo":
+            return [0, 1].map((k) => ({ head: String(k + 1), width: 1.2, cell: (t) => { const v = t.budo?.techniques?.[k]; return v === undefined ? "" : (w.techniques[v] ?? v).slice(0, 1).toUpperCase(); } }));
+        case "sumo":
+            return [{ head: w.kimarite, width: 4.2, cell: (t) => (t.budo?.kimarite === undefined || t.state !== "win" ? "" : w.kimariteName(t.budo.kimarite)) }];
+    }
+}
+/** The board as a group centred on the origin. `spot` is the room it has; it takes only what its rows and columns need. */
+export function budoBoardMarkup(sport, spot, left, right, words, o) {
+    const cols = columns(sport, words);
+    const team = [left, right];
+    const total = cols.reduce((sum, c) => sum + c.width, 0);
+    const units = 3 + total + 1.9;
+    const extra = (words.competition ? 0.8 : 0) + (words.foot ? 0.8 : 0);
+    const rows = 3 + extra;
+    const colU = Math.min(spot.w / units, spot.h / rows / 0.72);
+    const rowH = Math.min(spot.h / rows, colU * 0.72);
+    const w = colU * units;
+    const h = rowH * rows;
+    const x0 = -w / 2;
+    let y = -h / 2;
+    const parts = (names) => (o.parts ? names : undefined);
+    let inner = el("rect", { class: "ky-plate-bg", x: -w / 2, y: -h / 2, width: w, height: h, rx: Math.min(rowH * 0.5, w * 0.04) });
+    const band = (value, cls) => {
+        const bandH = rowH * 0.8;
+        inner += text(0, y + bandH / 2, value, fit(value, w * 0.92, bandH * 0.62), cls);
+        y += bandH;
+    };
+    if (words.competition)
+        band(words.competition, "ky-comp");
+    const nameW = colU * 3;
+    let cx = x0 + nameW;
+    const centres = [];
+    for (const c of cols) {
+        centres.push(cx + (c.width * colU) / 2);
+        inner += text(centres[centres.length - 1], y + rowH / 2, c.head, fit(c.head, c.width * colU * 0.9, rowH * 0.42), "ky-foot");
+        cx += c.width * colU;
+    }
+    const totalX = cx + colU * 0.95;
+    y += rowH;
+    for (const t of team) {
+        inner += el("rect", { class: `ky-panel-${t.side}`, x: x0 + 0.1 * colU, y: y + rowH * 0.06, width: nameW - 0.2 * colU, height: rowH * 0.88, rx: rowH * 0.2 });
+        const name = fitLines(t.name, (nameW - 0.3 * colU) * 0.92, rowH * 0.8, rowH * 0.5);
+        name.lines.forEach((line, k) => {
+            inner += text(x0 + 0.1 * colU + (nameW - 0.2 * colU) / 2, y + rowH / 2 + (k - (name.lines.length - 1) / 2) * name.size * 1.1, line, name.size, `ky-ink-${t.side}`);
+        });
+        cols.forEach((c, k) => {
+            const v = c.cell(t);
+            if (v !== "")
+                inner += text(centres[k], y + rowH / 2, v, fit(v, c.width * colU * 0.92, rowH * 0.56), "ky-score");
+        });
+        const size = fit(t.score, colU * 1.8, rowH * 0.76);
+        inner += el("g", { class: `ky-total ky-${t.state}`, part: parts(`score ${t.role}-score`) }, text(totalX, y + rowH / 2, t.score, size, "ky-score"));
+        if (t.state === "win")
+            inner += el("rect", { class: `ky-winbar ky-winbar-${t.side}`, x: totalX - (textWidth(t.score) * size) / 2, y: y + rowH / 2 + size * 0.5, width: textWidth(t.score) * size, height: Math.max(0.05, size * 0.06) });
+        y += rowH;
+    }
+    if (words.foot)
+        band(words.foot, "ky-foot");
+    return el("g", { class: "ky-plate ky-scoreboard", part: parts("plate") }, inner);
+}

package/dist/budo.score.d.ts

@@ -0,0 +1,18 @@
+import type { BudoScore, Sport, Team } from "./types.ts";
+/** The budō score of a team, cleaned: each count a whole number held to what the sport allows. */
+export interface BudoView {
+    ippon?: number;
+    wazaari?: number;
+    yuko?: number;
+    shido?: number;
+    senshu?: boolean;
+    techniques?: string[];
+    kimarite?: string;
+}
+/** Read a team's `budo`. */
+export declare function budoView(score: BudoScore | undefined): BudoView | undefined;
+/**
+ * The total of a side as its sport counts it, when the side gave no `score` of its own. Judo's scoreboard writes ippon (and two waza-ari, waza-ari-awasete-ippon) as 100, a waza-ari as 10 and a yuko as 1 (IJF
+ * SOR 2.5.5.1 and the scoreboard's notes); karate's points are yuko 1, waza-ari 2 and ippon 3 (WKF Kumite 8.6); kendo's is the number of its points (the techniques that are not hansoku).
+ */
+export declare function budoScoreText(sport: Sport, team: Pick<Team, "budo" | "score">): string | undefined;

package/dist/budo.score.js

@@ -0,0 +1,52 @@
+const whole = (v, hi) => (typeof v === "number" && Number.isFinite(v) && v >= 0 ? Math.min(hi, Math.floor(v)) : undefined);
+/** Read a team's `budo`. */
+export function budoView(score) {
+    if (score === undefined || score === null || typeof score !== "object")
+        return undefined;
+    const out = {};
+    const ippon = whole(score.ippon, 9);
+    const wazaari = whole(score.wazaari, 9);
+    const yuko = whole(score.yuko, 99);
+    const shido = whole(score.shido, 9);
+    if (ippon !== undefined)
+        out.ippon = ippon;
+    if (wazaari !== undefined)
+        out.wazaari = wazaari;
+    if (yuko !== undefined)
+        out.yuko = yuko;
+    if (shido !== undefined)
+        out.shido = shido;
+    if (score.senshu === true)
+        out.senshu = true;
+    if (Array.isArray(score.techniques))
+        out.techniques = score.techniques.filter((t) => typeof t === "string").map((t) => t.trim().toLowerCase().slice(0, 12)).filter((t) => t !== "").slice(0, 3);
+    if (typeof score.kimarite === "string" && score.kimarite.trim() !== "")
+        out.kimarite = score.kimarite.trim().slice(0, 40);
+    return Object.keys(out).length === 0 ? undefined : out;
+}
+/**
+ * The total of a side as its sport counts it, when the side gave no `score` of its own. Judo's scoreboard writes ippon (and two waza-ari, waza-ari-awasete-ippon) as 100, a waza-ari as 10 and a yuko as 1 (IJF
+ * SOR 2.5.5.1 and the scoreboard's notes); karate's points are yuko 1, waza-ari 2 and ippon 3 (WKF Kumite 8.6); kendo's is the number of its points (the techniques that are not hansoku).
+ */
+export function budoScoreText(sport, team) {
+    if (team.score !== undefined && team.score !== null && String(team.score).trim() !== "")
+        return undefined;
+    const v = budoView(team.budo);
+    if (v === undefined)
+        return undefined;
+    if (sport === "judo") {
+        if ((v.ippon ?? 0) > 0 || (v.wazaari ?? 0) >= 2)
+            return "100";
+        if (v.wazaari === undefined && v.yuko === undefined)
+            return undefined;
+        return String((v.wazaari ?? 0) * 10 + (v.yuko ?? 0));
+    }
+    if (sport === "karate") {
+        if (v.ippon === undefined && v.wazaari === undefined && v.yuko === undefined)
+            return undefined;
+        return String((v.ippon ?? 0) * 3 + (v.wazaari ?? 0) * 2 + (v.yuko ?? 0));
+    }
+    if (sport === "kendo")
+        return v.techniques === undefined ? undefined : String(v.techniques.filter((t) => t !== "hansoku").length);
+    return undefined;
+}

package/dist/budo.style.d.ts

@@ -0,0 +1,6 @@
+/** The rules of a dojo's gallery, the stands of a crowd in a dojo: brown seats and a rail, a few neutral people. */
+export declare const KYOGIJO_BUDO_GALLERY_STYLE = "\n.kyogijo .ky-bud-gbed.ky-bud-gbed{fill:var(--ky-bud-gal,#7a5a3c)}\n.kyogijo .ky-bud-gblk.ky-bud-gblk{fill:var(--ky-bud-gpeople,#a89a86)}\n.kyogijo .ky-bud-gseat.ky-bud-gseat{stroke:var(--ky-bud-grail,#3a2c1f);stroke-opacity:.3}\n.kyogijo .ky-bud-rail{stroke:var(--ky-bud-grail,#3a2c1f);stroke-width:1.6;stroke-opacity:.85}\n";
+/** The rules of a drawing of a budō sport in a look: the shared rules and the look's colours. Nothing for another sport. */
+export declare function budoStyle(sport: string, look?: string): string;
+/** Every budō sport's rules and every look, for a page that draws with `style: "none"` and supplies the stylesheet itself. */
+export declare const KYOGIJO_BUDO_STYLE: string;

package/dist/budo.style.js

@@ -0,0 +1,67 @@
+// The stylesheet of a budō drawing: the rules of its classes (the mats in three tones, the heri, the floor, the walls, the clay, the sand, the straw, the azuchi, the tape) in the sheet's own custom
+// properties, so that a named look, the options' `colors` and a page's own rule all win; and the colours of each budō look, in light and dark. See looks.ts for where the colours come from.
+import { BUDO_LOOKS } from "./budo/looks.js";
+const CLASSES = `
+.kyogijo .ky-bud-t1{fill:var(--ky-surface)}
+.kyogijo .ky-bud-t2{fill:var(--ky-surface-alt,var(--ky-surface))}
+.kyogijo .ky-bud-t3{fill:var(--ky-red)}
+.kyogijo .ky-bud-heri{fill:var(--ky-bud-heri,var(--ky-ink));fill-opacity:.82}
+.kyogijo .ky-bud-seam{stroke:var(--ky-ink);stroke-opacity:.26;fill:none;stroke-linejoin:round}
+.kyogijo .ky-bud-line{stroke:var(--ky-line);fill:none}
+.kyogijo .ky-bud-ink{stroke:var(--ky-ink);fill:none}
+.kyogijo .ky-bud-floor{fill:var(--ky-bud-floor,var(--ky-boards))}
+.kyogijo .ky-bud-wall{fill:var(--ky-boards)}
+.kyogijo .ky-bud-window{fill:var(--ky-blue,#2a5db0);fill-opacity:.55}
+.kyogijo .ky-bud-door{fill:var(--ky-apron)}
+.kyogijo .ky-bud-platform{fill:var(--ky-bud-floor,var(--ky-boards))}
+.kyogijo .ky-bud-free{fill:var(--ky-free,var(--ky-apron))}
+.kyogijo .ky-bud-desk{fill:var(--ky-ink);fill-opacity:.55}
+.kyogijo .ky-bud-seat{fill:var(--ky-ink);fill-opacity:.42}
+.kyogijo .ky-bud-shrine{fill:var(--ky-red)}
+.kyogijo .ky-bud-edge{stroke:#fff;stroke-opacity:.2;stroke-width:.03;fill:none}
+.kyogijo .ky-bud-dais{fill:var(--ky-bud-floor,var(--ky-boards));stroke:var(--ky-ink);stroke-opacity:.5;stroke-width:.04}
+.kyogijo .ky-bud-banner{fill:var(--ky-ink);fill-opacity:.85}
+.kyogijo .ky-bud-clay{fill:var(--ky-dirt)}
+.kyogijo .ky-bud-sand{fill:var(--ky-sand,#e8dcc2)}
+.kyogijo .ky-bud-tawara{fill:var(--ky-bud-straw,#c8a45c);stroke:var(--ky-ink);stroke-opacity:.45;stroke-width:.03}
+.kyogijo .ky-bud-azuchi{fill:var(--ky-dirt)}
+.kyogijo .ky-bud-yamichi{fill:var(--ky-surface)}
+.kyogijo .ky-bud-lane{fill:var(--ky-surface-alt,var(--ky-surface))}
+.kyogijo .ky-bud-mato{fill:var(--ky-line);stroke:var(--ky-ink);stroke-width:.04}
+.kyogijo .ky-bud-roof{fill:var(--ky-ink);fill-opacity:.12}
+.kyogijo .ky-bud-blue-fill{fill:var(--ky-blue,#2a5db0)}
+.kyogijo .ky-bud-white-fill{fill:var(--ky-line)}
+.kyogijo .ky-bud-red-fill{fill:var(--ky-red)}
+.kyogijo .ky-bud-ink-fill{fill:var(--ky-ink)}
+.kyogijo .ky-bud-tassel-e{fill:#2f9e63;stroke:var(--ky-ink);stroke-opacity:.5;stroke-width:.03}
+.kyogijo .ky-bud-tassel-s{fill:#d23b32;stroke:var(--ky-ink);stroke-opacity:.5;stroke-width:.03}
+.kyogijo .ky-bud-tassel-w{fill:#f4f1e8;stroke:var(--ky-ink);stroke-opacity:.5;stroke-width:.03}
+.kyogijo .ky-bud-tassel-n{fill:#232323;stroke:var(--ky-ink);stroke-opacity:.5;stroke-width:.03}`.trim();
+/** The custom properties of a look. */
+const vars = (l) => `--ky-surface:${l.surface};--ky-surface-alt:${l.alt};--ky-red:${l.red};--ky-apron:${l.apron};--ky-free:${l.free};--ky-bud-floor:${l.floor};--ky-boards:${l.boards}${l.dirt === undefined ? "" : `;--ky-dirt:${l.dirt}`}${l.sand === undefined ? "" : `;--ky-sand:${l.sand}`}${l.straw === undefined ? "" : `;--ky-bud-straw:${l.straw}`}`;
+/** The three rules of one look: light, dark by the device's setting, and dark by the page's `data-theme`. */
+function lookRules(sport, name) {
+    const pair = BUDO_LOOKS[sport][name];
+    const at = `[data-sport=${sport}][data-look=${name}]`;
+    return [
+        `:where(.kyogijo${at}){${vars(pair.light)}}`,
+        `@media (prefers-color-scheme:dark){:where(html:not([data-theme=light]) .kyogijo${at}:not([data-theme=light])){${vars(pair.dark)}}}`,
+        `:where(html[data-theme=dark] .kyogijo${at},.kyogijo[data-theme=dark]${at}){${vars(pair.dark)}}`,
+    ].join("\n");
+}
+/** The rules of a dojo's gallery, the stands of a crowd in a dojo: brown seats and a rail, a few neutral people. */
+export const KYOGIJO_BUDO_GALLERY_STYLE = `
+.kyogijo .ky-bud-gbed.ky-bud-gbed{fill:var(--ky-bud-gal,#7a5a3c)}
+.kyogijo .ky-bud-gblk.ky-bud-gblk{fill:var(--ky-bud-gpeople,#a89a86)}
+.kyogijo .ky-bud-gseat.ky-bud-gseat{stroke:var(--ky-bud-grail,#3a2c1f);stroke-opacity:.3}
+.kyogijo .ky-bud-rail{stroke:var(--ky-bud-grail,#3a2c1f);stroke-width:1.6;stroke-opacity:.85}
+`;
+/** The rules of a drawing of a budō sport in a look: the shared rules and the look's colours. Nothing for another sport. */
+export function budoStyle(sport, look) {
+    const kind = sport;
+    if (BUDO_LOOKS[kind] === undefined)
+        return "";
+    return `${CLASSES}\n${look === undefined ? lookRules(kind, Object.keys(BUDO_LOOKS[kind])[0]) : lookRules(kind, look)}`;
+}
+/** Every budō sport's rules and every look, for a page that draws with `style: "none"` and supplies the stylesheet itself. */
+export const KYOGIJO_BUDO_STYLE = `${CLASSES}${KYOGIJO_BUDO_GALLERY_STYLE}\n${Object.keys(BUDO_LOOKS).flatMap((sport) => Object.keys(BUDO_LOOKS[sport]).map((name) => lookRules(sport, name))).join("\n")}`;