@johnmorrisdotca/kyogijo-stadiums 0.10.2 → 0.12.0

package/dist/multi.draw.js

@@ -0,0 +1,324 @@
+// A tournament layout drawn: the package's own surfaces, each drawn by `drawKyogijo` and set where the layout puts it, on one floor, to scale, with the barriers, the officials' chairs, the scoreboard, the
+// boards and the empty places for the event's own words and marks; and, when asked, the hall's floor and a real stadium round it at the same scale. A surface is not drawn a second way here: its markup is
+// the drawing's own, moved. The same options always give the same string. The text alternative is `multiTable`.
+import { octagonD } from "./budo/plan.js";
+import { drawKyogijo } from "./draw.js";
+import { safeClass } from "./common.js";
+import { densityOf, layoutOf, resolveCrowd } from "./crowd.js";
+import { drawCrowd, KYOGIJO_CROWD_STYLE } from "./crowd.draw.js";
+import { el, esc, hash, num } from "./format.js";
+import { FEET_PER_METRE } from "./geometry.js";
+import { fitSentence, multiFit, multiLayout, multiNumber, needsSentence, venueOf } from "./multi.js";
+import { KYOGIJO_MULTI_STYLE } from "./multi.style.js";
+import { MULTI_WORDS } from "./multi.words.js";
+import { outlineOf } from "./outline.js";
+import { fill } from "./strings.js";
+import { textWidth } from "./text.js";
+import { VERSION } from "./version.js";
+const metres = (ft) => ft / FEET_PER_METRE;
+const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+/** One of the layout's surfaces as markup: the drawing's own, without its title, its stylesheet, its apron and its free zone (the layout draws the floor). */
+function inner(svg) {
+    const look = /^<svg[^>]* data-look="([^"]*)"/.exec(svg)?.[1];
+    const style = /<style>([\s\S]*?)<\/style>/.exec(svg)?.[1] ?? "";
+    let body = svg.replace(/<style>[\s\S]*?<\/style>/, "");
+    body = body.slice(body.indexOf("</desc>") + "</desc>".length, body.lastIndexOf("</svg>"));
+    body = body.replace(/<rect class="ky-(?:apron|free)(?: [^"]*)?"[^>]*\/>/g, "");
+    return { body, style, look };
+}
+/** The text of an empty place, sized to fit it. */
+function slotText(slot, words) {
+    return slot.kind === "floor-text" ? words.slots.floorText : slot.kind === "floor-logo" ? words.slots.floorLogo : words.slots.board;
+}
+/** The tag of a layout's floor in the drawing: the colour looks of `data-floor`, a budō floor wearing the mats'. */
+const floorClass = (layout) => (layout.spec.kind === "budo" ? "ky-bud-t2" : "ky-mu-floor");
+/**
+ * A tournament layout as one SVG string: several of the package's surfaces laid out together for one large event, to scale, on one floor. `preset` is one of `MULTI_PRESETS` (`tabletennis-4`, `pickleball-2x4`,
+ * `curling-1x4`, `judo-1x3`, `karate-2x3`, `badminton-1x4`, ...), or `layout` is your own; `rows`, `columns` and `stagger` change the grid. The empty places for the event's words and marks are drawn dashed and hold nothing.
+ * `venue` sets the layout in a hall's floor (a key of `MULTI_VENUES` or a size of your own) and the description says whether it fits; `stadium` draws a real stadium round the floor at the same scale, with the
+ * walls, the stands and the crowd the package draws for the sport. Light and dark follow the page; `multiTable` is the same thing as a table.
+ * @example
+ * ```ts
+ * import { drawMulti } from "@johnmorrisdotca/kyogijo-stadiums/multi";
+ * const svg = drawMulti({ preset: "tabletennis-4", stadium: true, venue: "ovo-arena-wembley" });
+ * console.log(svg.startsWith("<svg"), svg.includes("Table 4"));
+ * // true true
+ * ```
+ */
+export function drawMulti(options = {}) {
+    const o = options;
+    const language = o.language === "ja" ? "ja" : "en";
+    const words = MULTI_WORDS[language];
+    const layout = multiLayout(o);
+    const spec = layout.spec;
+    const venue = venueOf(o.venue);
+    const fit = venue === undefined ? undefined : multiFit(layout, venue);
+    const stadium = o.stadium === undefined || o.stadium === false ? undefined : o.stadium === true ? {} : o.stadium;
+    const gid = safeClass(o.id).replace(/ /g, "-") || `ky-mu-${hash(JSON.stringify([spec, o, VERSION]))}`;
+    const withSlots = o.slots !== false;
+    const withLabels = o.labels !== false;
+    // ---- The hall: the venue's floor, or the layout's own, and where the layout stands in it. ----
+    const turned = fit?.turned === true && fit.fits === true;
+    const lw = turned ? layout.floor.h : layout.floor.w;
+    const lh = turned ? layout.floor.w : layout.floor.h;
+    let hall = { w: lw, h: lh };
+    if (venue !== undefined && venue.shape === "rectangle") {
+        const L = venue.unit === "m" ? venue.length * FEET_PER_METRE : venue.length;
+        const W = venue.unit === "m" ? venue.width * FEET_PER_METRE : venue.width;
+        hall = { w: L, h: W };
+    }
+    else if (venue !== undefined && venue.shape === "octagon") {
+        const across = venue.across * FEET_PER_METRE;
+        hall = { w: across, h: across };
+    }
+    // The layout is set in the middle of the hall; one that does not fit still is, and hangs over.
+    const ox = (hall.w - lw) / 2;
+    const oy = (hall.h - lh) / 2;
+    const move = turned ? `translate(${num(ox + lw)} ${num(oy)}) rotate(90)` : `translate(${num(ox)} ${num(oy)})`;
+    const to = (x, y) => (turned ? [ox + lw - y, oy + x] : [ox + x, oy + y]);
+    // ---- The surfaces, each drawn by the package. ----
+    let style = "";
+    let look;
+    let cellsMarkup = "";
+    const surfaceBox = outlineOf(spec.surface).box;
+    const common = { ...spec.surface, margin: 0, language };
+    if (spec.kind === "budo") {
+        const drawn = inner(drawKyogijo({ ...common, id: `${gid}-s`, ...(o.style === "none" ? { style: "none" } : {}) }));
+        style = drawn.style;
+        look = drawn.look;
+        // The mats stand where the layout puts them: the drawing's own origin is the tatami's top left.
+        const t = layout.tatami;
+        cellsMarkup = el("g", { class: "ky-mu-cell", transform: `translate(${num(t.x - surfaceBox.x)} ${num(t.y - surfaceBox.y)})` }, drawn.body);
+    }
+    else {
+        layout.cells.forEach((cell, i) => {
+            const drawn = inner(drawKyogijo({ ...common, id: `${gid}-s${i + 1}`, style: i === 0 && o.style !== "none" ? "embed" : "none" }));
+            if (i === 0) {
+                style = drawn.style;
+                look = drawn.look;
+            }
+            // A surface turned a quarter stands across the layout: the drawing's own top left goes to the cell's top right, and the drawing is turned.
+            const place = cell.turn ? `translate(${num(cell.x + cell.w)} ${num(cell.y)}) rotate(90) translate(${num(-surfaceBox.x)} ${num(-surfaceBox.y)})` : `translate(${num(cell.x - surfaceBox.x)} ${num(cell.y - surfaceBox.y)})`;
+            cellsMarkup += el("g", { class: "ky-mu-cell", "data-cell": cell.n, transform: place }, drawn.body);
+        });
+    }
+    // ---- What stands on and round the floor. ----
+    let floorMarkup = "";
+    floorMarkup += el("rect", { class: floorClass(layout), x: 0, y: 0, width: num(layout.floor.w), height: num(layout.floor.h) });
+    let over = "";
+    if (spec.parts.barriers === true)
+        for (const c of layout.cells)
+            over += el("rect", { class: "ky-mu-barrier", x: num(c.bay.x + 0.5), y: num(c.bay.y + 0.5), width: num(c.bay.w - 1), height: num(c.bay.h - 1), rx: 0.4 });
+    if (spec.parts.officials === true) {
+        for (const c of layout.cells) {
+            if (c.turn) {
+                // Beside the net, on the right of a surface that stands across the layout.
+                const cy = c.y + c.h / 2;
+                over += el("rect", { class: "ky-mu-chair", x: num(c.x + c.w + 1.8), y: num(cy - 3.2), width: 1.6, height: 1.6, rx: 0.3 });
+                over += el("rect", { class: "ky-mu-desk", x: num(c.x + c.w + 1.5), y: num(cy - 0.8), width: 1.1, height: 3.6, rx: 0.2 });
+                continue;
+            }
+            const cx = c.x + c.w / 2;
+            over += el("rect", { class: "ky-mu-chair", x: num(cx + 1.6), y: num(c.y - 3.4), width: 1.6, height: 1.6, rx: 0.3 });
+            over += el("rect", { class: "ky-mu-desk", x: num(cx - 5), y: num(c.y - 3.1), width: 3.6, height: 1.1, rx: 0.2 });
+        }
+    }
+    if (spec.parts.scoreboard === "each")
+        for (const c of layout.cells)
+            over += el("rect", { class: "ky-mu-sb", x: num(c.x + c.w / 2 - 2), y: num(c.y + c.h + 1.2), width: 4, height: 1.4, rx: 0.2 });
+    const sb = layout.shared;
+    if (sb !== undefined) {
+        over += el("rect", { class: "ky-mu-sb", x: num(sb.x), y: num(sb.y), width: num(sb.w), height: num(sb.h), rx: 0.5 });
+        // One scoreboard for all: a quarter of it for each of four areas, or one panel for each when they are fewer or more.
+        const n = layout.cells.length;
+        const cols = n <= 4 ? Math.min(2, n) : n;
+        const rows = n <= 4 && n > 2 ? 2 : 1;
+        let cuts = "";
+        for (let i = 1; i < cols; i += 1)
+            cuts += `M${num(sb.x + (sb.w * i) / cols)} ${num(sb.y)}v${num(sb.h)}`;
+        for (let j = 1; j < rows; j += 1)
+            cuts += `M${num(sb.x)} ${num(sb.y + (sb.h * j) / rows)}h${num(sb.w)}`;
+        if (cuts !== "")
+            over += el("path", { class: "ky-mu-sb-cut", d: cuts, fill: "none" });
+    }
+    let slotsMarkup = "";
+    let slotTexts = "";
+    if (withSlots) {
+        for (const slot of layout.slots) {
+            const board = slot.kind === "board";
+            slotsMarkup += el("rect", { class: board ? "ky-mu-board" : "ky-mu-slot", x: num(slot.x), y: num(slot.y), width: num(slot.w), height: num(slot.h), "data-slot": slot.id });
+            if (board)
+                slotsMarkup += el("rect", { class: "ky-mu-slot ky-mu-slot-board", x: num(slot.x + 0.3), y: num(slot.y + 0.3), width: num(slot.w - 0.6), height: num(slot.h - 0.6) });
+            const text = slotText(slot, words);
+            const horizontal = slot.w >= slot.h;
+            const long = horizontal ? slot.w : slot.h;
+            const short = horizontal ? slot.h : slot.w;
+            const size = clamp(Math.min(short * 0.5, (long * 0.9) / Math.max(1, textWidth(text))), 0.5, 4);
+            const [tx, ty] = to(slot.x + slot.w / 2, slot.y + slot.h / 2);
+            // The words of a slot on a long side are laid along it; in a turned layout they turn back to read from the left.
+            const rot = (horizontal ? 0 : -90) + 0;
+            slotTexts += el("text", { class: `ky-mu-slot-text${board ? " ky-mu-slot-text-board" : ""}`, x: num(tx), y: num(ty + size * 0.34), "font-size": num(size), transform: rot === 0 ? undefined : `rotate(${rot} ${num(tx)} ${num(ty)})` }, esc(text));
+        }
+    }
+    let labelsMarkup = "";
+    if (withLabels) {
+        for (const c of layout.cells) {
+            const size = clamp(Math.min(c.bay.w, c.bay.h) * 0.075, 1.1, 3.4);
+            let lx;
+            let ly;
+            let anchor = "start";
+            if (spec.kind === "budo") {
+                [lx, ly] = to(c.x + c.w / 2, c.y + c.h * 0.16);
+                anchor = "middle";
+            }
+            else {
+                // At the outer corner of its bay, so that the labels stay clear of what hangs over the middle of the floor.
+                const right = spec.columns > 1 && c.column >= spec.columns / 2;
+                const below = spec.rows > 1 && spec.columns > 1 && c.row >= spec.rows / 2;
+                [lx, ly] = to(right ? c.bay.x + c.bay.w - 1.4 : c.bay.x + 1.4, below ? c.bay.y + c.bay.h - size * 0.5 : c.bay.y + size * 1.3);
+                anchor = right !== turned ? "end" : "start";
+            }
+            labelsMarkup += el("text", { class: "ky-mu-label", x: num(lx), y: num(ly), "font-size": num(size), "text-anchor": anchor }, esc(c.label));
+        }
+    }
+    // ---- The hall and the stadium round it. ----
+    let hallMarkup = "";
+    let reach = { left: 0, right: 0, top: 0, bottom: 0 };
+    let defs = "";
+    let crowdStyle = "";
+    const wide = { x: 0, y: 0, w: hall.w, h: hall.h };
+    const boards = layout.slots.filter((s) => s.kind === "board");
+    const boardsMargin = withSlots && boards.length > 0 ? 5 : 0;
+    if (venue !== undefined || stadium !== undefined) {
+        const look = venue?.floor !== undefined && venue.floor !== "neutral" ? ` ky-mu-hf-${venue.floor}` : "";
+        if (venue?.shape === "octagon") {
+            const a = hall.w / 2;
+            hallMarkup += el("path", { class: `ky-mu-hallfloor${look}`, d: octagonD(a, a, a) });
+        }
+        else
+            hallMarkup += el("rect", { class: `ky-mu-hallfloor${look}`, x: 0, y: 0, width: num(hall.w), height: num(hall.h) });
+    }
+    if (stadium !== undefined) {
+        const standsLike = venue?.standsLike ?? spec.sport;
+        const crowd = resolveCrowd({ gaps: false, awayEnd: "none", roof: stadium.roof, shape: stadium.shape, density: stadium.density, detail: stadium.detail === "plain" ? "plain" : "fine" });
+        const stands = layoutOf({ sport: standsLike, box: wide, crowd, awaySide: "right", arena: venue?.shape === "octagon" });
+        const density = stadium.crowd === false ? 0 : densityOf(crowd, stands.seats, undefined);
+        const drawn = drawCrowd(stands, { id: `${gid}-cr`, crowd, density, fine: crowd.detail !== "plain", ground: "ky-mu-apron" });
+        defs += drawn.defs;
+        const wall = venue?.shape === "octagon" ? el("path", { class: "ky-mu-wall", d: octagonD(hall.w / 2, hall.w / 2, hall.w / 2) }) : el("rect", { class: "ky-mu-wall", x: 0, y: 0, width: num(hall.w), height: num(hall.h), rx: 0.5 });
+        hallMarkup = drawn.markup + hallMarkup + wall;
+        reach = stands.reach;
+        crowdStyle = KYOGIJO_CROWD_STYLE;
+    }
+    else if (venue !== undefined) {
+        hallMarkup += el("rect", { class: "ky-mu-hall", x: 0, y: 0, width: num(hall.w), height: num(hall.h) });
+    }
+    const bad = fit !== undefined && fit.fits === false;
+    const overhang = bad ? el("rect", { class: "ky-mu-over", x: num(ox), y: num(oy), width: num(lw), height: num(lh) }) : "";
+    // ---- The picture. ----
+    const room = Math.max(4, Math.min(hall.w, hall.h) * 0.03);
+    const view = {
+        x: Math.min(wide.x - reach.left, ox) - room - boardsMargin,
+        y: Math.min(wide.y - reach.top, oy) - room - boardsMargin,
+        x1: Math.max(wide.x + wide.w + reach.right, ox + lw) + room + boardsMargin,
+        y1: Math.max(wide.y + wide.h + reach.bottom, oy + lh) + room + boardsMargin,
+    };
+    const vw = view.x1 - view.x;
+    const vh = view.y1 - view.y;
+    const sentences = [
+        fill(words.say.drawn, { name: spec.name[language], surfaces: layout.needs.surfaces, length: multiNumber(layout.needs.length, language), width: multiNumber(layout.needs.width, language), area: multiNumber(layout.needs.area, language) }),
+        fill(words.say.grid, { rows: spec.rows, columns: spec.columns }),
+    ];
+    if (spec.stagger !== undefined && spec.stagger > 0)
+        sentences.push(fill(words.say.stagger, { share: `${Math.round(spec.stagger * 100)}%` }));
+    if (layout.shared !== undefined)
+        sentences.push(words.say.shared);
+    if (withSlots && layout.slots.some((s) => s.kind !== "board"))
+        sentences.push(fill(words.say.slots, { n: layout.slots.filter((s) => s.kind !== "board").length }));
+    if (spec.event !== undefined) {
+        const named = language === "ja" ? spec.event.ja : undefined;
+        sentences.push(fill(words.say.event, { event: named?.name ?? spec.event.name, year: spec.event.year, venue: named?.venue ?? spec.event.venue, city: named?.city ?? spec.event.city }));
+    }
+    sentences.push(spec.basis === "event" ? words.say.basisEvent : words.say.basisRulebook);
+    if (venue !== undefined && fit !== undefined)
+        sentences.push(fill(words.say.venue, { venue: venue.name[language], fit: fitSentence(fit, language) }));
+    if (stadium !== undefined)
+        sentences.push(words.say.stadium);
+    const title = o.title ?? fill(words.say.title, { name: spec.name[language] });
+    const description = o.description ?? sentences.join(language === "ja" ? "" : " ");
+    const titleId = `${gid}-t`;
+    const descId = `${gid}-d`;
+    const css = o.style === "none" ? "" : `<style>${style}\n${KYOGIJO_MULTI_STYLE}${crowdStyle === "" ? "" : `\n${crowdStyle}`}</style>`;
+    const hallLayer = hallMarkup === "" ? "" : hallMarkup;
+    const group = el("g", { class: "ky-mu-layout", transform: move }, floorMarkup + cellsMarkup + over + slotsMarkup);
+    const root = el("svg", {
+        xmlns: "http://www.w3.org/2000/svg",
+        class: `kyogijo ky-multi ky-${spec.sport}${safeClass(o.className) === "" ? "" : ` ${safeClass(o.className)}`}`,
+        viewBox: `${num(view.x)} ${num(view.y)} ${num(vw)} ${num(vh)}`,
+        role: "img",
+        "aria-labelledby": `${titleId} ${descId}`,
+        "data-sport": spec.sport,
+        "data-layout": spec.id,
+        "data-grid": `${spec.rows}x${spec.columns}`,
+        "data-look": look,
+        "data-floor": spec.floor,
+        "data-fit": fit === undefined ? undefined : fit.fits === null ? "maybe" : String(fit.fits),
+        "data-stadium": stadium === undefined ? undefined : "on",
+        "data-theme": o.theme === "light" || o.theme === "dark" ? o.theme : undefined,
+        "data-version": VERSION,
+    }, `<title id="${titleId}">${esc(title)}</title><desc id="${descId}">${esc(description)}</desc>` + css + (defs === "" ? "" : `<defs>${defs}</defs>`) + el("rect", { class: "ky-mu-apron", x: num(view.x), y: num(view.y), width: num(vw), height: num(vh) }) + hallLayer + group + overhang + slotTexts + labelsMarkup);
+    return root;
+}
+/** Where an empty place is, in words: the surface it belongs to, the side or end it is at, and whether it is on the mats. */
+function slotWhere(slot, layout, words) {
+    const where = words.table.where;
+    const parts = [];
+    const cell = /^(?:text|logo)-(\d+)(?:-(top|bottom|start|end))?$/.exec(slot.id);
+    const common = /^logo-common-(\d+)$/.exec(slot.id);
+    const side = /^(?:board|text)-(top|bottom|left|right)$/.exec(slot.id) ?? /^text-(\d+)-(top|bottom)$/.exec(slot.id);
+    if (common !== null)
+        parts.push(layout.cells[Number(common[1]) - 1].label, where.common);
+    else if (cell !== null) {
+        parts.push(layout.cells[Number(cell[1]) - 1].label);
+        if (cell[2] !== undefined)
+            parts.push(where[cell[2]]);
+    }
+    else if (side !== null)
+        parts.push(where[side[side.length - 1]]);
+    else if (slot.id === "logo-start")
+        parts.push(where.start);
+    else if (slot.id === "logo-end")
+        parts.push(where.end);
+    if (slot.onMat)
+        parts.push(words.table.onMat);
+    return parts.join(words === MULTI_WORDS.ja ? "、" : ", ");
+}
+/**
+ * The same thing as the picture, as a table: each playing surface with its row, column, place and size in metres, and each empty place for the event's words and marks, under a caption that gives
+ * what the layout needs. For a reader who cannot see the drawing, and for a page that wants the figures.
+ * @example
+ * ```ts
+ * import { multiTable } from "@johnmorrisdotca/kyogijo-stadiums/multi";
+ * const table = multiTable({ preset: "tabletennis-4" });
+ * console.log(table.startsWith("<table"), table.includes("Table 4"));
+ * // true true
+ * ```
+ */
+export function multiTable(options = {}) {
+    const language = options.language === "ja" ? "ja" : "en";
+    const words = MULTI_WORDS[language];
+    const layout = multiLayout(options);
+    const t = words.table;
+    const m = (ft) => multiNumber(metres(ft), language);
+    const head = `<thead><tr><th scope="col">${esc(t.surface)}</th><th scope="col">${esc(t.row)}</th><th scope="col">${esc(t.column)}</th><th scope="col">${esc(t.x)}</th><th scope="col">${esc(t.y)}</th><th scope="col">${esc(t.size)}</th></tr></thead>`;
+    const rows = layout.cells.map((c) => `<tr><th scope="row">${esc(c.label)}</th><td>${c.row + 1}</td><td>${c.column + 1}</td><td>${m(c.x)}</td><td>${m(c.y)}</td><td>${m(c.w)} × ${m(c.h)}</td></tr>`).join("");
+    const slotRows = options.slots === false ? "" : layout.slots.map((s) => `<tr><th scope="row">${esc(t.slot)}: ${esc(slotText(s, words))}</th><td colspan="2">${esc(slotWhere(s, layout, words))}</td><td>${m(s.x)}</td><td>${m(s.y)}</td><td>${m(s.w)} × ${m(s.h)}</td></tr>`).join("");
+    const caption = language === "ja" ? `${fill(t.caption, { name: layout.spec.name[language] })}。必要な床：${needsSentence(layout.needs, language)}` : `${fill(t.caption, { name: layout.spec.name[language] })} ${needsSentence(layout.needs, language)}`;
+    return `<table class="ky-table" data-kind="multi"><caption>${esc(caption)}</caption>${head}<tbody>${rows}${slotRows}</tbody></table>`;
+}
+/** The hall of a layout as the drawing sets it, for a page that wants to say so: the venue, its fit, and the floor the layout needs. */
+export function multiSetting(options) {
+    const layout = multiLayout(options);
+    const venue = venueOf(options.venue);
+    return { venue, fit: venue === undefined ? undefined : multiFit(layout, venue), layout };
+}

package/dist/multi.js

@@ -0,0 +1,286 @@
+// A tournament layout laid out: several of the package's own surfaces on one floor, to scale, where each stands and what it leaves free; the floor the layout needs; and whether it fits a hall's floor. The
+// figures are in multi.data.ts (a rulebook's, with its source); this file only adds them up. Nothing here draws SVG (multi.draw.ts does), and every function returns new values.
+import { inOctagon } from "./budo/plan.js";
+import { fill } from "./strings.js";
+import { FEET_PER_METRE } from "./geometry.js";
+import { IJF_CONTEST, WKF_KUMITE } from "./leagues/budo.js";
+import { MULTI_PRESETS, MULTI_VENUES, multiPreset, multiVenueById } from "./multi.data.js";
+import { MULTI_WORDS } from "./multi.words.js";
+import { outlineOf } from "./outline.js";
+/** The most rows or columns a layout takes. */
+export const MULTI_MAX = 12;
+const feet = (v, unit) => (unit === "m" ? v * FEET_PER_METRE : v);
+const metres = (ft) => ft / FEET_PER_METRE;
+const round = (v, places = 2) => {
+    const k = 10 ** places;
+    return Math.round(v * k) / k;
+};
+/** A number as a language writes it: thousands separated, two decimals at most (`3,234.5`). */
+export const multiNumber = (value, language = "en") => new Intl.NumberFormat(language === "ja" ? "ja-JP" : "en-US", { maximumFractionDigits: 2 }).format(value);
+const finite = (v) => typeof v === "number" && Number.isFinite(v);
+/** A whole number of 1 to `max`, or an error that says which option it is. */
+function count(value, name, max) {
+    if (!Number.isInteger(value) || value < 1 || value > max)
+        throw new RangeError(`${name} is a whole number of 1 to ${max}`);
+    return value;
+}
+/**
+ * The layout the options ask for: a preset or a layout of the caller's own, with the grid and the stagger it is given in place of its own.
+ * @throws Error for a preset that is not one, an option that is not a whole number or a share, or neither a preset nor a layout.
+ */
+export function specOf(o) {
+    const base = o.layout ?? (o.preset === undefined ? undefined : multiPreset(o.preset));
+    if (base === undefined) {
+        if (o.preset !== undefined && o.layout === undefined)
+            throw new Error(`Unknown preset "${o.preset}": use one of ${MULTI_PRESETS.map((p) => p.id).join(", ")}`);
+        throw new TypeError("A tournament layout needs a preset or a layout");
+    }
+    const budo = base.kind === "budo";
+    const rows = o.rows === undefined ? base.rows : count(o.rows, "rows", budo ? 6 : MULTI_MAX);
+    const columns = o.columns === undefined ? base.columns : count(o.columns, "columns", budo ? 6 : MULTI_MAX);
+    if (o.stagger !== undefined && (!finite(o.stagger) || o.stagger < 0 || o.stagger > 1))
+        throw new RangeError("stagger is a share from 0 to 1");
+    const stagger = o.stagger ?? base.stagger;
+    const surface = budo ? { ...base.surface, budo: { ...base.surface.budo, areas: { across: columns, down: rows } } } : base.surface;
+    return { ...base, rows, columns, ...(stagger === undefined ? {} : { stagger }), surface };
+}
+const size = (s) => ({ length: feet(s.length, s.unit), width: feet(s.width, s.unit) });
+/** The slots on and round a floor, in feet. */
+function slotsFor(spec, cells, floor, tatami) {
+    const out = [];
+    const brand = spec.parts.brand ?? "none";
+    const boardDepth = 3; // three feet: a board of about 0.9 m
+    if (brand === "mat" && tatami !== undefined) {
+        // A budō floor is printed on the mats themselves: the event's words in the safety area above and below each contest area, and a mark in the end safety areas and in the common safe zones.
+        const { safety: s, gap } = tatami;
+        for (const cell of cells) {
+            const textW = cell.w * 0.9;
+            const textH = s * 0.45;
+            // The band between two rows serves both: the words are set under the upper area only.
+            if (cell.row === 0)
+                out.push({ id: `text-${cell.n}-top`, kind: "floor-text", onMat: true, x: cell.x + (cell.w - textW) / 2, y: cell.y - s / 2 - textH / 2, w: textW, h: textH });
+            out.push({ id: `text-${cell.n}-bottom`, kind: "floor-text", onMat: true, x: cell.x + (cell.w - textW) / 2, y: cell.y + cell.h + s / 2 - textH / 2, w: textW, h: textH });
+        }
+        const mark = Math.min(s, gap) * 0.7;
+        const cy = tatami.y + tatami.h / 2;
+        out.push({ id: "logo-start", kind: "floor-logo", onMat: true, x: tatami.x + s / 2 - mark / 2, y: cy - mark / 2, w: mark, h: mark });
+        out.push({ id: "logo-end", kind: "floor-logo", onMat: true, x: tatami.x + tatami.w - s / 2 - mark / 2, y: cy - mark / 2, w: mark, h: mark });
+        cells.forEach((cell, k) => {
+            if (k % Math.max(1, spec.columns) === spec.columns - 1)
+                return;
+            const gx = cell.x + cell.w + gap / 2;
+            out.push({ id: `logo-common-${cell.n}`, kind: "floor-logo", onMat: true, x: gx - mark / 2, y: cell.y + cell.h / 2 - mark / 2, w: mark, h: mark });
+        });
+    }
+    else if (brand === "floor") {
+        // Each surface has two places for a mark at its ends (the ITTF's rule allows up to 6 advertisements on the floor of an area) and one for words beside it. A surface turned a quarter has its ends above and below it.
+        for (const cell of cells) {
+            const mx = (cell.bay.w - cell.w) / 2;
+            const my = (cell.bay.h - cell.h) / 2;
+            if (cell.turn) {
+                const room = Math.min(my, cell.bay.w * 0.5);
+                if (room >= 3) {
+                    const m = room * 0.6;
+                    out.push({ id: `logo-${cell.n}-start`, kind: "floor-logo", onMat: false, x: cell.x + cell.w / 2 - m / 2, y: cell.y - room / 2 - m / 2, w: m, h: m });
+                    out.push({ id: `logo-${cell.n}-end`, kind: "floor-logo", onMat: false, x: cell.x + cell.w / 2 - m / 2, y: cell.y + cell.h + room / 2 - m / 2, w: m, h: m });
+                }
+                // The words stand along the left side, the officials' chair being on the right.
+                if (mx >= 4) {
+                    const w = Math.min(mx * 0.4, 3.5);
+                    const h = cell.bay.h * 0.55;
+                    out.push({ id: `text-${cell.n}`, kind: "floor-text", onMat: false, x: cell.x - mx / 2 - w / 2, y: cell.y + cell.h / 2 - h / 2, w, h });
+                }
+                continue;
+            }
+            const room = Math.min(mx, cell.bay.h * 0.5);
+            if (room >= 3) {
+                const m = room * 0.6;
+                out.push({ id: `logo-${cell.n}-start`, kind: "floor-logo", onMat: false, x: cell.x - room / 2 - m / 2, y: cell.y + cell.h / 2 - m / 2, w: m, h: m });
+                out.push({ id: `logo-${cell.n}-end`, kind: "floor-logo", onMat: false, x: cell.x + cell.w + room / 2 - m / 2, y: cell.y + cell.h / 2 - m / 2, w: m, h: m });
+            }
+            if (my >= 4) {
+                const h = Math.min(my * 0.4, 3.5);
+                const w = cell.bay.w * 0.55;
+                // The words go on the side of the surface that the officials' chair is not on.
+                const y = spec.parts.officials === true ? cell.y + cell.h + my / 2 - h / 2 : cell.y - my / 2 - h / 2;
+                out.push({ id: `text-${cell.n}`, kind: "floor-text", onMat: false, x: cell.x + cell.w / 2 - w / 2, y, w, h });
+            }
+        }
+    }
+    if (spec.parts.boards === true) {
+        const gap = 1;
+        out.push({ id: "board-top", kind: "board", onMat: false, x: 0, y: -gap - boardDepth, w: floor.w, h: boardDepth });
+        out.push({ id: "board-bottom", kind: "board", onMat: false, x: 0, y: floor.h + gap, w: floor.w, h: boardDepth });
+        out.push({ id: "board-left", kind: "board", onMat: false, x: -gap - boardDepth, y: 0, w: boardDepth, h: floor.h });
+        out.push({ id: "board-right", kind: "board", onMat: false, x: floor.w + gap, y: 0, w: boardDepth, h: floor.h });
+    }
+    return out;
+}
+/**
+ * A layout laid out: where each surface stands, the floor it needs and the empty places for the event's own words and marks, all in feet from the top left corner of the floor (and the floor's size
+ * and what the layout needs in metres).
+ * @example
+ * ```ts
+ * import { multiLayout } from "@johnmorrisdotca/kyogijo-stadiums/multi";
+ * const layout = multiLayout({ preset: "tabletennis-4" });
+ * console.log(layout.cells.length, layout.needs.length, layout.needs.width);
+ * // 4 28 14
+ * ```
+ */
+export function multiLayout(options = {}) {
+    const spec = specOf(options);
+    const language = options.language === "ja" ? "ja" : "en";
+    const words = MULTI_WORDS[language];
+    const name = (n) => fill(words.names[spec.word], { n });
+    const cells = [];
+    let floor;
+    let tatami;
+    if (spec.kind === "budo") {
+        // The contest area, the safety area, the common safe zone between areas and the free zone, in metres: judo's from the IJF's figures (or the options'), karate's from the WKF's kumite area.
+        const karate = spec.sport === "karate";
+        const opts = spec.surface.budo ?? {};
+        const c = karate ? WKF_KUMITE.area : opts.size ?? IJF_CONTEST.contest.drawn;
+        const s = karate ? WKF_KUMITE.safety : opts.safety ?? IJF_CONTEST.safety.drawn;
+        const gap = karate ? WKF_KUMITE.between : Math.max(IJF_CONTEST.common, s);
+        const free = karate ? 0 : IJF_CONTEST.freeZone;
+        const across = spec.columns;
+        const down = spec.rows;
+        const tw = across * c + (across - 1) * gap + 2 * s;
+        const th = down * c + (down - 1) * gap + 2 * s;
+        floor = { w: feet(tw + 2 * free, "m"), h: feet(th + 2 * free, "m") };
+        tatami = { x: feet(free, "m"), y: feet(free, "m"), w: feet(tw, "m"), h: feet(th, "m"), safety: feet(s, "m"), gap: feet(gap, "m") };
+        for (let j = 0; j < down; j += 1) {
+            for (let i = 0; i < across; i += 1) {
+                const x = feet(free + s + i * (c + gap), "m");
+                const y = feet(free + s + j * (c + gap), "m");
+                const w = feet(c, "m");
+                const b = feet(gap / 2, "m");
+                cells.push({ n: cells.length + 1, label: name(cells.length + 1), row: j, column: i, x, y, w, h: w, turn: false, bay: { x: x - b, y: y - b, w: w + 2 * b, h: w + 2 * b } });
+            }
+        }
+    }
+    else {
+        const box = outlineOf(spec.surface).box;
+        const turn = spec.turn === 90;
+        const sw = turn ? box.h : box.w;
+        const sh = turn ? box.w : box.h;
+        const bay = spec.bay === undefined ? { length: sw, width: sh } : size(spec.bay);
+        const edge = spec.edge === undefined ? { length: (bay.length - sw) / 2, width: (bay.width - sh) / 2 } : size(spec.edge);
+        const shift = spec.stagger === undefined ? 0 : spec.stagger * bay.length;
+        for (let j = 0; j < spec.rows; j += 1) {
+            for (let i = 0; i < spec.columns; i += 1) {
+                const x = edge.length + i * bay.length + (j % 2 === 1 ? shift : 0);
+                const y = edge.width + j * bay.width;
+                const mx = (bay.length - sw) / 2;
+                const my = (bay.width - sh) / 2;
+                cells.push({ n: cells.length + 1, label: name(cells.length + 1), row: j, column: i, x, y, w: sw, h: sh, turn, bay: { x: x - mx, y: y - my, w: bay.length, h: bay.width } });
+            }
+        }
+        floor = { w: 2 * edge.length + (spec.columns - 1) * bay.length + sw + (spec.rows > 1 ? shift : 0), h: 2 * edge.width + (spec.rows - 1) * bay.width + sh };
+    }
+    const slots = spec.parts.brand === "none" && spec.parts.boards !== true ? [] : slotsFor(spec, cells, floor, tatami);
+    const needs = { length: round(metres(floor.w)), width: round(metres(floor.h)), area: round(metres(floor.w) * metres(floor.h), 1), surfaces: cells.length };
+    const layout = { spec, cells, slots, floor, needs };
+    if (tatami !== undefined)
+        layout.tatami = { x: tatami.x, y: tatami.y, w: tatami.w, h: tatami.h };
+    if (spec.parts.scoreboard === "shared") {
+        // 12 by 6 feet (ours), wider when there are more than four areas to give a panel each.
+        const w = Math.min(Math.max(12, 3 * cells.length), floor.w * 0.5);
+        layout.shared = { x: floor.w / 2 - w / 2, y: floor.h / 2 - 3, w, h: 6 };
+    }
+    return layout;
+}
+/** A hall as the caller gives it, or a key of `MULTI_VENUES`. @throws Error for a key that is not one, a size that is not positive. */
+export function venueOf(venue) {
+    if (venue === undefined)
+        return undefined;
+    if (typeof venue === "string") {
+        const found = multiVenueById(venue);
+        if (found === undefined)
+            throw new Error(`Unknown venue "${venue}": use one of ${MULTI_VENUES.map((v) => v.id).join(", ")}`);
+        return found;
+    }
+    if ("shape" in venue)
+        return venue;
+    if (!finite(venue.length) || !finite(venue.width) || venue.length <= 0 || venue.width <= 0)
+        throw new RangeError("A venue of your own needs a length and a width above 0");
+    const unit = venue.unit === "ft" ? "ft" : "m";
+    return {
+        id: "custom",
+        name: { en: "Your floor", ja: "指定した床" },
+        shape: "rectangle",
+        length: venue.length,
+        width: venue.width,
+        unit,
+        what: { en: `a floor of ${venue.length} by ${venue.width} ${unit === "m" ? "metres" : "feet"}`, ja: `${venue.length}×${venue.width}${unit === "m" ? "m" : "フィート"}の床` },
+        standsLike: "badminton",
+        sources: [],
+    };
+}
+/**
+ * Whether a layout fits a hall's floor. A floor that is a rectangle takes the layout as it is or turned a quarter; an octagon takes it if its corners are inside; a floor of which only the area is published
+ * can only be compared by area, and says so (`fits` is `null` when the area is enough, because the shape may still not take it).
+ * @example
+ * ```ts
+ * import { multiFit, multiLayout } from "@johnmorrisdotca/kyogijo-stadiums/multi";
+ * const four = multiFit(multiLayout({ preset: "curling-1x4" }), "nhl-ice-pad");
+ * const six = multiFit(multiLayout({ preset: "curling-1x4", columns: 6 }), "nhl-ice-pad");
+ * console.log(four.fits, four.turned, six.fits);
+ * // true true false
+ * ```
+ */
+export function multiFit(layout, venue) {
+    const v = venueOf(venue);
+    if (v === undefined)
+        throw new TypeError("multiFit needs a venue");
+    const needs = layout.needs;
+    if (v.shape === "area") {
+        const have = v.area ?? 0;
+        return { fits: needs.area <= have ? null : false, turned: false, by: "area", needs, spare: { area: round(have - needs.area, 1) }, floor: { area: have } };
+    }
+    if (v.shape === "octagon") {
+        const a = v.across / 2;
+        const L = needs.length;
+        const W = needs.width;
+        const asIs = inOctagon(0, 0, a, L / 2, W / 2);
+        const turned = inOctagon(0, 0, a, W / 2, L / 2);
+        const fits = asIs || turned;
+        // The spare is the octagon's width across the flats less the layout's, on each axis (the octagon is widest across the flats: its corners are cut).
+        return { fits, turned: !asIs && turned, by: "size", needs, spare: { length: round(2 * a - L), width: round(2 * a - W) }, floor: { across: v.across, area: v.area ?? round(8 * a * a * (Math.SQRT2 - 1), 1) } };
+    }
+    const length = v.unit === "m" ? v.length : metres(v.length);
+    const width = v.unit === "m" ? v.width : metres(v.width);
+    const asIs = needs.length <= length + 1e-9 && needs.width <= width + 1e-9;
+    const turned = needs.width <= length + 1e-9 && needs.length <= width + 1e-9;
+    const floorArea = round(v.area ?? length * width, 1);
+    if (asIs || turned) {
+        const useTurn = !asIs;
+        return { fits: true, turned: useTurn, by: "size", needs, spare: useTurn ? { length: round(length - needs.width), width: round(width - needs.length) } : { length: round(length - needs.length), width: round(width - needs.width) }, floor: { length: round(length), width: round(width), area: floorArea } };
+    }
+    const as = { length: round(length - needs.length), width: round(width - needs.width) };
+    const tu = { length: round(length - needs.width), width: round(width - needs.length) };
+    const shortAs = Math.min(0, as.length) + Math.min(0, as.width);
+    const shortTu = Math.min(0, tu.length) + Math.min(0, tu.width);
+    const useTurn = shortTu > shortAs;
+    return { fits: false, turned: useTurn, by: "size", needs, spare: useTurn ? tu : as, floor: { length: round(length), width: round(width), area: floorArea } };
+}
+/** The sentence that says how a layout sits in a hall, in a language. */
+export function fitSentence(fit, language = "en") {
+    const w = MULTI_WORDS[language].fit;
+    const turned = fit.turned ? w.turned : "";
+    if (fit.by === "area") {
+        const spare = fit.spare;
+        const n = (v) => multiNumber(v, language);
+        return spare.area >= 0 ? fill(w.maybe, { need: n(fit.needs.area), have: n(fit.floor.area) }) : fill(w.tooSmall, { need: n(fit.needs.area), have: n(fit.floor.area) });
+    }
+    const spare = fit.spare;
+    const n = (v) => multiNumber(v, language);
+    if (fit.fits === true)
+        return fill(w.fits, { length: n(spare.length), width: n(spare.width), turned });
+    return fill(w.short, { length: n(round(Math.max(0, -spare.length))), width: n(round(Math.max(0, -spare.width))), turned });
+}
+/** The size of a layout as words, in a language: `28 by 14 metres (392 square metres)`; along the layout first, then across it. */
+export const needsSentence = (needs, language = "en") => {
+    const n = (v) => multiNumber(v, language);
+    return language === "ja" ? `横${n(needs.length)}m×縦${n(needs.width)}m（${n(needs.area)}平方メートル）` : `${n(needs.length)} by ${n(needs.width)} metres (${n(needs.area)} square metres)`;
+};

package/dist/multi.style.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The rules of a tournament layout. `:where` keeps the specificity at nothing so that a page's own custom properties win; the layout's group follows the device and the page like a drawing does, and a
+ * `data-theme` of light or dark forces it.
+ */
+export declare const KYOGIJO_MULTI_STYLE: string;