@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.6.0

package/dist/surfaces/basketball.js

@@ -1,6 +1,8 @@
 import { el, num } from "../format.js";
 import { rulesFor } from "../eras.js";
 import { NBA_COURT } from "../leagues/basketball.js";
+import { bench, hoops } from "./basketball.gear.js";
+import { hardwoodFloor, hardwoodWords } from "./basketball.floor.js";
 import { atEnds, edges, ft, quarterTurn, textOn } from "./surface.js";
 /**
  * A basketball court: the floor, the keys, the arcs, the circles, the baskets and the small marks. By default the NBA's, as the
@@ -8,14 +10,16 @@ import { atEnds, edges, ft, quarterTurn, textOn } from "./surface.js";
  */
 export function basketball(o, era, court = NBA_COURT) {
     // The NBA's court has a history of its own (eras.ts); a league's, if it has one, is already in its `court`.
-    const nba = court === NBA_COURT ? (era ?? rulesFor("nba").rules) : undefined;
+    const nba = court === NBA_COURT || era !== undefined ? (era ?? rulesFor("nba").rules) : undefined;
     const { length: L, width: W } = court;
     const m = o.margin ?? 7;
     const view0 = { x: -m, y: -m, w: L + 2 * m, h: W + 2 * m };
     const cy = W / 2;
     const full = o.detail === "full";
     const bw = 2.6;
-    const thin = o.exact ? 1 / 6 : 0.4;
+    // A realistic floor (`court.hardwood`) paints its lines nearer to a real court's two inches, unless it is small and they would vanish.
+    const hw = o.court?.hardwood;
+    const thin = o.exact ? 1 / 6 : hw?.fine === true ? 0.3 : 0.4;
     const turned = o.portrait;
     const laneWidth = nba?.keyWidth ?? court.laneWidth;
     const half = laneWidth / 2;
@@ -29,34 +33,42 @@ export function basketball(o, era, court = NBA_COURT) {
     const J = three === null ? 0 : bx + Math.sqrt(radius * radius - (W / 2 - inset) * (W / 2 - inset));
     const threeLeft = () => `M0 ${num(inset)}H${num(J)}A${num(radius)} ${num(radius)} 0 0 1 ${num(J)} ${num(W - inset)}H0`;
     const threeRight = () => `M${num(L)} ${num(inset)}H${num(L - J)}A${num(radius)} ${num(radius)} 0 0 0 ${num(L - J)} ${num(W - inset)}H${num(L)}`;
+    // A realistic floor lays boards under the paint and the seams and the sheen over it; the clean floor is as it always was.
+    const floor = hw === undefined ? undefined : hardwoodFloor(hw, { L, W, bw, margin: m, id: o.id }, o);
     let base = el("rect", { class: ft(o, "apron", "ky-apron"), x: view0.x, y: view0.y, width: view0.w, height: view0.h });
-    base += el("path", { class: ft(o, "border", "ky-boards"), "fill-rule": "evenodd", d: `M${-bw} ${-bw}H${num(L + bw)}V${num(W + bw)}H${-bw}ZM0 0V${num(W)}H${num(L)}V0Z` });
-    base += el("rect", { class: ft(o, "floor", "ky-surface"), x: 0, y: 0, width: L, height: W });
-    if (o.stripes) {
-        // The planks run along the court: a second tone on every other board.
-        const planks = [];
-        for (let y = 1; y < W; y += 2)
-            planks.push(`M0 ${y}H${num(L)}v1H0z`);
-        base += el("path", { class: ft(o, "planks", "ky-stripe"), d: planks.join("") });
+    if (floor !== undefined)
+        base += floor.under;
+    else {
+        base += el("path", { class: ft(o, "border", "ky-boards"), "fill-rule": "evenodd", d: `M${-bw} ${-bw}H${num(L + bw)}V${num(W + bw)}H${-bw}ZM0 0V${num(W)}H${num(L)}V0Z` });
+        base += el("rect", { class: ft(o, "floor", "ky-surface"), x: 0, y: 0, width: L, height: W });
+        if (o.stripes) {
+            // The planks run along the court: a second tone on every other board.
+            const planks = [];
+            for (let y = 1; y < W; y += 2)
+                planks.push(`M0 ${y}H${num(L)}v1H0z`);
+            base += el("path", { class: ft(o, "planks", "ky-stripe"), d: planks.join("") });
+        }
     }
     // The keys, painted, and the three-point areas when asked.
     const keyW = court.freeThrowLine;
     const wide = (court.laneEndWidth ?? laneWidth) / 2;
     if (o.court?.paintThreePoint && three !== null) {
-        base += el("path", { class: ft(o, "three-point-area", "ky-key ky-key-left"), d: `${threeLeft()}Z` });
-        base += el("path", { class: ft(o, "three-point-area", "ky-key ky-key-right"), d: `${threeRight()}Z` });
+        base += el("path", { class: ft(o, "three-point-area", "ky-key ky-key-left"), "fill-opacity": hw?.stain, d: `${threeLeft()}Z` });
+        base += el("path", { class: ft(o, "three-point-area", "ky-key ky-key-right"), "fill-opacity": hw?.stain, d: `${threeRight()}Z` });
     }
     // A lane that is a rectangle, or a trapezoid wider at the baseline.
     const lane = (x, away) => `M${num(x)} ${num(cy - wide)}L${num(x + away * keyW)} ${num(cy - half)}V${num(cy + half)}L${num(x)} ${num(cy + wide)}`;
     if (court.laneEndWidth === undefined) {
-        base += el("rect", { class: ft(o, "key", "ky-key ky-key-left"), x: 0, y: cy - half, width: keyW, height: laneWidth });
-        base += el("rect", { class: ft(o, "key", "ky-key ky-key-right"), x: L - keyW, y: cy - half, width: keyW, height: laneWidth });
+        base += el("rect", { class: ft(o, "key", "ky-key ky-key-left"), "fill-opacity": hw?.stain, x: 0, y: cy - half, width: keyW, height: laneWidth });
+        base += el("rect", { class: ft(o, "key", "ky-key ky-key-right"), "fill-opacity": hw?.stain, x: L - keyW, y: cy - half, width: keyW, height: laneWidth });
     }
     else {
-        base += el("path", { class: ft(o, "key", "ky-key ky-key-left"), d: `${lane(0, 1)}Z` });
-        base += el("path", { class: ft(o, "key", "ky-key ky-key-right"), d: `${lane(L, -1)}Z` });
+        base += el("path", { class: ft(o, "key", "ky-key ky-key-left"), "fill-opacity": hw?.stain, d: `${lane(0, 1)}Z` });
+        base += el("path", { class: ft(o, "key", "ky-key ky-key-right"), "fill-opacity": hw?.stain, d: `${lane(L, -1)}Z` });
     }
-    base += el("circle", { class: ft(o, "centre-paint", "ky-centre"), cx: L / 2, cy, r: court.centreRadius });
+    base += el("circle", { class: ft(o, "centre-paint", "ky-centre"), "fill-opacity": hw?.stain, cx: L / 2, cy, r: court.centreRadius });
+    if (floor !== undefined)
+        base += floor.over;
     let lines = el("rect", { class: ft(o, "boundary", "ky-line"), x: 0, y: 0, width: L, height: W, "stroke-width": thin * 1.25, fill: "none" });
     lines += el("path", { class: ft(o, "halfway-line", "ky-line"), d: `M${num(L / 2)} 0V${num(W)}`, "stroke-width": thin, fill: "none" });
     lines += el("circle", { class: ft(o, "centre-circle", "ky-line"), cx: L / 2, cy, r: court.centreRadius, "stroke-width": thin, fill: "none" });
@@ -103,7 +115,11 @@ export function basketball(o, era, court = NBA_COURT) {
                 return el("path", { class: ft(o, "backboards", "ky-board"), d: `${boardLine}${arm}`, "stroke-width": 0.5, fill: "none" }) + el("circle", { class: ft(o, "rims", "ky-rim"), cx: rimX, cy, r: court.rim, "stroke-width": 0.3, fill: "none" });
         }
     };
-    if (o.goalMarkup === undefined && (o.goals === undefined || o.goals === "box")) {
+    if (hw?.hoops === true && o.goalMarkup === undefined && (o.goals === undefined || o.goals === "box")) {
+        // The baskets of a hardwood floor: the stanchion, the board and the rim seen from above, with their shadows.
+        lines += hoops(o, hw, court, { L, W, bw });
+    }
+    else if (o.goalMarkup === undefined && (o.goals === undefined || o.goals === "box")) {
         lines += el("path", { class: ft(o, "backboards", "ky-board"), d: `M${num(back)} ${num(cy - board)}V${num(cy + board)}M${num(L - back)} ${num(cy - board)}V${num(cy + board)}M${num(back)} ${num(cy)}H${num(bx - court.rim)}M${num(L - back)} ${num(cy)}H${num(L - bx + court.rim)}`, "stroke-width": 0.5, fill: "none" });
         lines += el("circle", { class: ft(o, "rims", "ky-rim"), cx: bx, cy, r: court.rim, "stroke-width": 0.3, fill: "none" });
         lines += el("circle", { class: ft(o, "rims", "ky-rim"), cx: L - bx, cy, r: court.rim, "stroke-width": 0.3, fill: "none" });
@@ -134,17 +150,22 @@ export function basketball(o, era, court = NBA_COURT) {
         if (marks.substitution !== null)
             lines += el("path", { class: ft(o, "court-marks", "ky-line"), d: [L / 2 - marks.substitution, L / 2 + marks.substitution].map((x) => `M${num(x)} ${num(W)}v${num(-side.length)}`).join(""), "stroke-width": thin, fill: "none" });
     }
-    // The court's own words and logo: the baseline words in the apron, the logo in the centre circle.
+    // The court's own words and logo: the baseline words in the apron, the logo in the centre circle. A hardwood floor sets the words in its border instead.
     const words = o.court?.baselineText;
-    if (words !== undefined) {
+    if (hw !== undefined)
+        lines += hardwoodWords(o, { L, W, bw, margin: m, id: o.id }, turned, o.court?.sidelineText);
+    else if (words !== undefined) {
         const x = -bw - 1.4;
         lines += textOn(turned, x, cy + 1.1, words[0], { size: 3, anchor: "middle", rot: -90, cls: ft(o, "baseline-text", "ky-baseline"), weight: 800, spacing: 0.3 });
         lines += textOn(turned, L - x, cy + 1.1, words[1], { size: 3, anchor: "middle", rot: 90, cls: ft(o, "baseline-text", "ky-baseline"), weight: 800, spacing: 0.3 });
     }
     if (o.court?.centreLogo !== undefined) {
-        const s = court.centreRadius * 1.5;
+        const s = court.centreRadius * (hw === undefined ? 1.5 : 1.8);
         lines += el("image", { href: o.court.centreLogo, x: L / 2 - s / 2, y: cy - s / 2, width: s, height: s, preserveAspectRatio: "xMidYMid meet", transform: turned ? `rotate(-90 ${num(L / 2)} ${num(cy)})` : undefined });
     }
+    // Beside the bottom sideline: the coaching box, the scorers' table and the benches.
+    if (hw?.bench === true)
+        lines += bench(o, { L, W, bw, box: marks?.sideline.fromBaseline ?? L * 0.3, thin }, m);
     // The teams' places and the score's panel, in proportion to the court (the NBA's is 94 feet by 50).
     const kx = L / NBA_COURT.length;
     const ky = W / NBA_COURT.width;
@@ -153,7 +174,7 @@ export function basketball(o, era, court = NBA_COURT) {
         view: view0,
         base,
         lines,
-        defs: "",
+        defs: floor?.defs ?? "",
         left: { cx: 16.5 * kx, cy, w: 27 * kx, h: 25 * ky, rot: 0, panel: true },
         right: { cx: L - 16.5 * kx, cy, w: 27 * kx, h: 25 * ky, rot: 0, panel: true },
         plate: { cx: L / 2, cy, w: 34 * kx, h: 20 * ky },
@@ -162,6 +183,7 @@ export function basketball(o, era, court = NBA_COURT) {
     };
     surface.lineRef = { width: thin, feet: 1 };
     surface.box = { x: 0, y: 0, w: L, h: W };
+    surface.centreRadius = court.centreRadius;
     // The paint: the lane from the baseline to the free-throw line and the circle beyond it, with a little floor round them.
     const paintDeep = keyW + R + 1.5;
     const paintHalf = Math.min(cy, Math.max(half, wide, R) + 2);

package/dist/surfaces/budo.d.ts

@@ -0,0 +1,6 @@
+import type { BudoPlan } from "../budo/plan.ts";
+import { type BuildOptions, type Surface } from "./surface.ts";
+/** Feet in a metre. */
+export declare const K: number;
+/** The surface of the plan lying wide. `margin` is the ground round what is drawn, in feet. */
+export declare function budoSurface(o: BuildOptions, plan: BudoPlan, margin: number): Surface;

package/dist/surfaces/budo.js

@@ -0,0 +1,104 @@
+// A budō surface lying wide, from its plan (budo/plan.ts): the floor and the free zone, the mats in their tones with their heri and their seams, the walls, the clay and the straw of a dohyō, the tape,
+// the targets. The plan is in metres; the drawing is in feet, as every surface lies, so the whole is drawn inside a group that scales metres to feet and moves the surface's box to the origin.
+import { el } from "../format.js";
+import { areaD, marks, strokes } from "./field.js";
+import { atEnds, edges, ft, quarterTurn } from "./surface.js";
+/** Feet in a metre. */
+export const K = 1 / 0.3048;
+const feetBox = (b, ox, oy) => edges((b.x0 - ox) * K, (b.y0 - oy) * K, (b.x1 - ox) * K, (b.y1 - oy) * K);
+/** A plan's named range in feet, as a surface lists them. */
+function rangeOf(r, ox, oy) {
+    return "left" in r ? atEnds((end) => feetBox(end === "left" ? r.left : r.right, ox, oy)) : feetBox(r, ox, oy);
+}
+/** The surface of the plan lying wide. `margin` is the ground round what is drawn, in feet. */
+export function budoSurface(o, plan, margin) {
+    const ox = plan.box.x0;
+    const oy = plan.box.y0;
+    const full = o.detail === "full";
+    const view0 = { x: (plan.extent.x0 - ox) * K - margin, y: (plan.extent.y0 - oy) * K - margin, w: (plan.extent.x1 - plan.extent.x0) * K + 2 * margin, h: (plan.extent.y1 - plan.extent.y0) * K + 2 * margin };
+    const place = `scale(${K.toFixed(6)}) translate(${(-ox).toFixed(4)} ${(-oy).toFixed(4)})`;
+    const group = (inner, cls) => el("g", { class: cls, transform: place }, inner);
+    const turned = o.portrait;
+    let base = el("rect", { class: ft(o, "apron", "ky-apron"), x: view0.x, y: view0.y, width: view0.w, height: view0.h });
+    let ground = "";
+    let defs = "";
+    // The weave of a mat, over the tones and under the heri and the seams: a ridge and its highlight, a repeating gradient that every mat shares (one `<defs>` entry, which a `<pattern>` would
+    // have to share with the background's), turned a quarter for a mat that lies across. Drawn only at full detail.
+    const pieces = plan.dojo?.pieces ?? plan.judo?.pieces ?? [];
+    const weave = full && plan.texture && pieces.length > 0;
+    const stripe = (at, colour, opacity, width) => el("stop", { offset: at, "stop-color": colour, "stop-opacity": 0 }) + el("stop", { offset: at, "stop-color": colour, "stop-opacity": opacity }) + el("stop", { offset: at + width, "stop-color": colour, "stop-opacity": opacity }) + el("stop", { offset: at + width, "stop-color": colour, "stop-opacity": 0 });
+    const woven = () => {
+        defs += el("linearGradient", { id: `${o.id}-weave`, x1: 0, y1: 0, x2: 0, y2: 0.1, gradientUnits: "userSpaceOnUse", spreadMethod: "repeat" }, stripe(0.1, "#000000", 0.16, 0.22) + stripe(0.52, "#ffffff", 0.14, 0.16));
+        const rect = (p) => `M${p.x0} ${p.y0}H${p.x1}V${p.y1}H${p.x0}Z`;
+        // A mat that lies across is drawn in a group turned a quarter, with its corners turned back, so that its ridges run along it.
+        const turned = (p) => `M${p.y0} ${-p.x0}H${p.y1}V${-p.x1}H${p.y0}Z`;
+        const across = pieces.filter((p) => p.along === "x");
+        const down = pieces.filter((p) => p.along === "y");
+        let out = "";
+        if (across.length > 0)
+            out += el("path", { class: "ky-bud-weave", d: across.map(rect).join(""), fill: `url(#${o.id}-weave)` });
+        if (down.length > 0)
+            out += el("g", { transform: "rotate(90)" }, el("path", { class: "ky-bud-weave", d: down.map(turned).join(""), fill: `url(#${o.id}-weave)` }));
+        // A faint light line along the edge of each mat, where its rounded edge catches the light.
+        out += el("path", { class: "ky-bud-edge", d: pieces.map(rect).join(""), fill: "none" });
+        return out;
+    };
+    let pending = false;
+    let wove = false;
+    for (const a of plan.areas) {
+        const tone = a.cls === "ky-bud-t1" || a.cls === "ky-bud-t2" || a.cls === "ky-bud-t3";
+        if (weave && !wove && pending && !tone) {
+            wove = true;
+            ground += woven();
+        }
+        if (tone)
+            pending = true;
+        ground += el("path", { class: ft(o, a.feature, a.cls), d: areaD(a), "fill-rule": a.evenodd === true ? "evenodd" : undefined });
+    }
+    if (weave && !wove)
+        ground += woven();
+    base += group(ground, "ky-bud-ground");
+    const thick = o.exact ? plan.lineWidth : plan.drawnLine;
+    // The seams are the plan's finest lines: left out of a drawing that asks for the simple detail.
+    const shown = full ? plan : { ...plan, shapes: plan.shapes.filter((s) => s.feature !== "seams" && s.feature !== "boards") };
+    const lines = group(strokes(shown, o) + marks(shown, o), "ky-bud-lines");
+    const W = (plan.box.x1 - plan.box.x0) * K;
+    const H = (plan.box.y1 - plan.box.y0) * K;
+    const cx = (plan.centre.x - ox) * K;
+    const cy = (plan.centre.y - oy) * K;
+    // The score's board lies on the middle of the surface; the teams are named on it, not painted on the mats.
+    const plateW = Math.min(W * 0.52, 190);
+    // The names a score paints (kyūdō's and a dojo's: the others have a board): on the shajō's floor and over the yamichi, or either side of the middle.
+    const kyu = plan.kyudo;
+    const places = kyu === undefined ? { left: { cx: W * 0.27, cy: H / 2, w: W * 0.2, h: H * 0.11, rot: 0 }, right: { cx: W * 0.73, cy: H / 2, w: W * 0.2, h: H * 0.11, rot: 0 } } : { left: { cx: ((kyu.shajo.x0 + kyu.shajo.x1) / 2 - ox) * K, cy: H * 0.3, w: (kyu.shajo.x1 - kyu.shajo.x0) * K * 0.5, h: H * 0.09, rot: 0 }, right: { cx: ((kyu.yamichi.x0 + kyu.yamichi.x1) / 2 + (kyu.yamichi.x1 - kyu.yamichi.x0) / 4 - ox) * K, cy: (((kyu.yamichi.y0 + kyu.yamichi.y1) / 2) - oy) * K, w: (kyu.yamichi.x1 - kyu.yamichi.x0) * K * 0.3, h: H * 0.09, rot: 0 } };
+    const surface = {
+        sport: plan.sport,
+        view: view0,
+        base,
+        lines,
+        defs,
+        left: places.left,
+        right: places.right,
+        plate: { cx, cy, w: plateW, h: plateW * 0.55 },
+        turned,
+        bannersOver: true,
+        onColour: false,
+        centreRadius: plan.centre.r * K,
+    };
+    surface.box = { x: 0, y: 0, w: W, h: H };
+    surface.lineRef = { width: thick, feet: K };
+    const ranges = {};
+    for (const [name, r] of Object.entries(plan.ranges))
+        ranges[name] = rangeOf(r, ox, oy);
+    surface.ranges = ranges;
+    if (o.landmarks === true) {
+        const m = plan.marks.map((p) => ({ id: p.id, x: (p.x - ox) * K, y: (p.y - oy) * K, side: p.side }));
+        surface.marks = full ? m : m.filter((p) => !p.id.startsWith("~"));
+    }
+    if (turned) {
+        const t = quarterTurn(view0);
+        surface.view = t.view;
+        surface.turn = t.turn;
+    }
+    return surface;
+}

package/dist/surfaces/curling.d.ts

@@ -12,9 +12,25 @@ export interface SheetLook {
     end: "left" | "right";
     /** Which league's marks to draw: the hack line and the courtesy lines are World Curling's. */
     figures: SheetSpec;
+    /** For `show: "folded"`: what each enlarged panel holds, the shape of the whole, and the words that label the panels (the left end's and the right end's). */
+    fold?: {
+        panels: "half" | "house";
+        fit: number;
+        labels: readonly [string, string];
+    };
 }
 /** Where each tee is on the sheet, along it from the left backboard: the left tee and the right tee. */
 export declare function teesOf(spec: Pick<SheetSpec, "length" | "teeFromMiddle">): [number, number];
+/**
+ * The part of a bare sheet's ice that `show` and `end` show, in feet in the sheet's wide frame: all of it, or the half from the hog line to the back line, or the house, at one end,
+ * with a little ice beyond the lines. A folded sheet shows all of it, with its houses enlarged beside it.
+ */
+export declare function shownIce(spec: Pick<SheetSpec, "length" | "width" | "teeFromMiddle" | "backLine" | "hogLine" | "rings" | "lineWidths">, show: SheetShow, end: "left" | "right"): {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
 /**
  * A curling sheet in the frame of a drawing lying wide: x along it from the left backboard, y across it from the top sideline. A house at
  * each end (the 12-, 8- and 4-foot circles and the button), the tee, back, hog and centre lines, the hacks, and, in World Curling's, the

package/dist/surfaces/curling.fold.d.ts

@@ -0,0 +1,67 @@
+import type { SheetSpec } from "../leagues/curling.ts";
+/** A box in the sheet's wide frame, in feet. */
+interface Wide {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** One enlarged end. */
+export interface FoldPanel {
+    end: "left" | "right";
+    /** The part of the sheet it shows, in the sheet's own feet (the boards included across it). */
+    crop: Wide;
+    /** Where it is drawn, in the wide frame of the whole drawing. */
+    box: Wide;
+    /** The transform of the part of the sheet that fills it, and the id of the clip that cuts it to `crop`. */
+    transform: string;
+    clip: string;
+    /** Where along the sheet, in the wide frame of the drawing, the blank ice between the house and the hog line is centred: a label stands there. Missing when the panel holds only the house. */
+    free?: number;
+}
+/** The folded layout of a sheet. */
+export interface FoldPlan {
+    /** How much larger than the strip each panel is drawn. */
+    scale: number;
+    /** The viewBox of the drawing as it lies wide: the strip is at y = 0 to the sheet's width, and the panels are above and below it. */
+    view: Wide;
+    /** The left end's panel first and the right end's second. */
+    panels: [FoldPanel, FoldPanel];
+}
+/** What the layout is worked out from. */
+export interface FoldOptions {
+    /** What each panel holds: the half from the hog line to the back line, or the house. */
+    panels: "half" | "house";
+    /** The width of the drawing as the eye sees it over its height. */
+    fit: number;
+    /** The ground round the whole, in feet. */
+    margin: number;
+    /** True when the drawing lies tall: its panels are then at its left and right, and the left end's is at the left. */
+    turned: boolean;
+    /** A prefix for the ids of the clips. */
+    id: string;
+}
+/** The part of the sheet an end's panel shows, in the sheet's own feet along it (the boards included across it). */
+export declare function foldCrop(spec: SheetSpec, tee: number, end: "left" | "right", panels: "half" | "house"): Wide;
+/**
+ * Where everything of a folded sheet goes. The strip keeps its own place (x along the sheet from 0 to its length, y across it from 0), so that a data layer's numbers are the same
+ * on the strip as on a sheet drawn whole; each panel is the same drawing at a larger scale, which is chosen so that the whole has the shape asked for (`fit`), and which
+ * is never less than the strip's own nor wider than the strip.
+ */
+export declare function foldPlan(spec: SheetSpec, tees: readonly [number, number], o: FoldOptions): FoldPlan;
+/** The clips of the panels: each cuts the sheet to the part its panel shows. */
+export declare const foldClips: (plan: FoldPlan) => string;
+/** The sheet's own markup laid in each panel, cut to the part the panel shows. */
+export declare const foldCopies: (plan: FoldPlan, markup: string) => string;
+/**
+ * What joins each panel to the part of the strip it enlarges: a faint fan from the panel's edge to that part, and a frame round the part, as an inset on a map is joined to what it shows.
+ * The panels' own frames are drawn here too.
+ */
+export declare function foldLinks(plan: FoldPlan, sheetWidth: number): string;
+/**
+ * The label of each panel, in a small plate that is upright whichever way the drawing lies. It stands in the free ground beyond the panel's far end, in line with the panel's middle (the
+ * panels are as long as the strip allows, not as long as the frame, so there is room there); when there is none, over the blank ice of a half between the house and the hog line.
+ * `labels` are the words for the left end's panel and the right end's.
+ */
+export declare function foldLabels(plan: FoldPlan, labels: readonly [string, string], turned: boolean): string;
+export {};

package/dist/surfaces/curling.fold.js

@@ -0,0 +1,107 @@
+// The folded curling sheet: the whole sheet as a strip, and the two houses enlarged beside it, so that a sheet 150 feet long and 15 wide fills a roughly square frame. As a
+// tall drawing the top house is enlarged on the left of the strip and the bottom house on the right; as a wide one the left house is above the strip and the right house below it.
+// The layout is worked out here, in the sheet's wide frame, and the builder only draws it. Written for this package.
+import { el, num } from "../format.js";
+import { textWidth } from "../text.js";
+/** The ground, in feet, between the strip and each panel, across which the panel is joined to the part of the strip it enlarges. */
+const GAP = 4;
+/** The width of the boards round the ice, as the sheet draws them. */
+const BOARD = 0.7;
+/** The ice kept beyond the lines of the part of an end that a panel shows. */
+const ALONG = 1.5;
+/** The part of the sheet an end's panel shows, in the sheet's own feet along it (the boards included across it). */
+export function foldCrop(spec, tee, end, panels) {
+    const [twelve] = spec.rings;
+    const hogW = spec.lineWidths.hog;
+    const outer = panels === "half" ? spec.hogLine + hogW : twelve;
+    const x0 = end === "left" ? tee - spec.backLine - ALONG : tee - outer - ALONG;
+    const x1 = end === "left" ? tee + outer + ALONG : tee + spec.backLine + ALONG;
+    return { x: x0, y: -BOARD, w: x1 - x0, h: spec.width + 2 * BOARD };
+}
+/**
+ * Where everything of a folded sheet goes. The strip keeps its own place (x along the sheet from 0 to its length, y across it from 0), so that a data layer's numbers are the same
+ * on the strip as on a sheet drawn whole; each panel is the same drawing at a larger scale, which is chosen so that the whole has the shape asked for (`fit`), and which
+ * is never less than the strip's own nor wider than the strip.
+ */
+export function foldPlan(spec, tees, o) {
+    const across = spec.width + 2 * BOARD;
+    const crops = [foldCrop(spec, tees[0], "left", o.panels), foldCrop(spec, tees[1], "right", o.panels)];
+    const whole = spec.length + 2 * o.margin;
+    // The height of the whole as the drawing lies wide: the strip, two panels and the ground round them. The eye's width over height is `fit`, which a tall drawing turns the other way.
+    const ratio = o.turned ? o.fit : 1 / o.fit;
+    const wanted = (ratio * whole - 2 * o.margin - 2 * GAP - across) / (2 * across);
+    const widest = Math.min(spec.length / crops[0].w, spec.length / crops[1].w);
+    const scale = Math.max(1, Math.min(wanted, widest));
+    const high = across * scale;
+    // The left end is at the bottom of a drawing that lies wide when it is to be turned, because the turn sends the bottom to the left.
+    const tops = o.turned ? ["right", "left"] : ["left", "right"];
+    const make = (end) => {
+        const crop = crops[end === "left" ? 0 : 1];
+        const w = crop.w * scale;
+        const top = tops[0] === end;
+        const x = end === "left" ? -BOARD : spec.length + BOARD - w;
+        const y = top ? -BOARD - GAP - high : spec.width + BOARD + GAP;
+        // The blank ice of a half: between the outer edge of the house and the hog line, towards the middle of the sheet.
+        const toward = end === "left" ? 1 : -1;
+        const mid = tees[end === "left" ? 0 : 1] + (toward * (spec.rings[0] + spec.hogLine)) / 2;
+        return {
+            free: o.panels === "half" ? x + (mid - crop.x) * scale : undefined,
+            end,
+            crop,
+            box: { x, y, w, h: high },
+            transform: `matrix(${num(scale)} 0 0 ${num(scale)} ${num(x - crop.x * scale)} ${num(y + BOARD * scale)})`,
+            clip: `${o.id}-fold-${end}`,
+        };
+    };
+    const left = make("left");
+    const right = make("right");
+    const top = Math.min(left.box.y, right.box.y);
+    const bottom = Math.max(left.box.y, right.box.y) + high;
+    return { scale, view: { x: -o.margin, y: top - o.margin, w: whole, h: bottom - top + 2 * o.margin }, panels: [left, right] };
+}
+/** The clips of the panels: each cuts the sheet to the part its panel shows. */
+export const foldClips = (plan) => plan.panels.map((p) => el("clipPath", { id: p.clip }, el("rect", { x: num(p.crop.x), y: num(p.crop.y), width: num(p.crop.w), height: num(p.crop.h) }))).join("");
+/** The sheet's own markup laid in each panel, cut to the part the panel shows. */
+export const foldCopies = (plan, markup) => plan.panels.map((p) => el("g", { class: "ky-fold", transform: p.transform, "clip-path": `url(#${p.clip})` }, markup)).join("");
+/**
+ * What joins each panel to the part of the strip it enlarges: a faint fan from the panel's edge to that part, and a frame round the part, as an inset on a map is joined to what it shows.
+ * The panels' own frames are drawn here too.
+ */
+export function foldLinks(plan, sheetWidth) {
+    let out = "";
+    for (const p of plan.panels) {
+        const above = p.box.y < 0;
+        const edge = above ? p.box.y + p.box.h : p.box.y;
+        const meet = above ? -BOARD : sheetWidth + BOARD;
+        const { x: a, w } = p.crop;
+        out += el("path", { class: "ky-fold-link", d: `M${num(p.box.x)} ${num(edge)}L${num(a)} ${num(meet)}H${num(a + w)}L${num(p.box.x + p.box.w)} ${num(edge)}Z` });
+        out += el("path", { class: "ky-fold-edge", fill: "none", d: `M${num(p.box.x)} ${num(edge)}L${num(a)} ${num(meet)}M${num(p.box.x + p.box.w)} ${num(edge)}L${num(a + w)} ${num(meet)}` });
+        out += el("rect", { class: "ky-fold-hl", x: num(a), y: num(-BOARD), width: num(w), height: num(sheetWidth + 2 * BOARD) });
+        out += el("rect", { class: "ky-fold-frame", x: num(p.box.x), y: num(p.box.y), width: num(p.box.w), height: num(p.box.h) });
+    }
+    return out;
+}
+/**
+ * The label of each panel, in a small plate that is upright whichever way the drawing lies. It stands in the free ground beyond the panel's far end, in line with the panel's middle (the
+ * panels are as long as the strip allows, not as long as the frame, so there is room there); when there is none, over the blank ice of a half between the house and the hog line.
+ * `labels` are the words for the left end's panel and the right end's.
+ */
+export function foldLabels(plan, labels, turned) {
+    const size = Math.max(1.2, Math.min(5.5, 0.03 * Math.max(plan.view.w, plan.view.h)));
+    const inset = size * 0.6;
+    const high = size * 1.9;
+    return plan.panels
+        .map((p, i) => {
+        const wide = textWidth(labels[i]) * size + size * 1.6;
+        // The plate's length along the sheet is its height when the drawing is turned.
+        const extent = turned ? high : wide;
+        const room = p.end === "left" ? plan.view.x + plan.view.w - (p.box.x + p.box.w) : p.box.x - plan.view.x;
+        const beyond = room >= extent + 2 * inset;
+        const cy = p.box.y + p.box.h / 2;
+        const cx = beyond ? (p.end === "left" ? p.box.x + p.box.w + inset + extent / 2 : p.box.x - inset - extent / 2) : (p.free ?? p.box.x + p.box.w / 2);
+        const plate = el("rect", { class: "ky-fold-pill", x: num(-wide / 2), y: num(-high / 2), width: num(wide), height: num(high), rx: num(size * 0.4) });
+        const text = el("text", { class: "ky-text ky-fold-t", x: 0, y: num(size * 0.36), "text-anchor": "middle", "font-size": num(size), "font-weight": 700 }, labels[i].replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;"));
+        return el("g", { class: "ky-fold-label", transform: `translate(${num(cx)} ${num(cy)})${turned ? " rotate(-90)" : ""}` }, plate + text);
+    })
+        .join("");
+}

package/dist/surfaces/curling.js

@@ -1,9 +1,24 @@
 import { el, num } from "../format.js";
 import { ft, quarterTurn } from "./surface.js";
+import { foldClips, foldCopies, foldLabels, foldLinks, foldPlan } from "./curling.fold.js";
 /** Where each tee is on the sheet, along it from the left backboard: the left tee and the right tee. */
 export function teesOf(spec) {
     return [spec.length / 2 - spec.teeFromMiddle, spec.length / 2 + spec.teeFromMiddle];
 }
+/**
+ * The part of a bare sheet's ice that `show` and `end` show, in feet in the sheet's wide frame: all of it, or the half from the hog line to the back line, or the house, at one end,
+ * with a little ice beyond the lines. A folded sheet shows all of it, with its houses enlarged beside it.
+ */
+export function shownIce(spec, show, end) {
+    if (show !== "half" && show !== "house")
+        return { x: 0, y: 0, w: spec.length, h: spec.width };
+    const along = 1.5;
+    const [tl, tr] = teesOf(spec);
+    const outer = show === "half" ? spec.hogLine + spec.lineWidths.hog : spec.rings[0];
+    const x0 = end !== "right" ? tl - spec.backLine - along : tr - outer - along;
+    const x1 = end !== "right" ? tl + outer + along : tr + spec.backLine + along;
+    return { x: x0, y: 0, w: x1 - x0, h: spec.width };
+}
 /**
  * A curling sheet in the frame of a drawing lying wide: x along it from the left backboard, y across it from the top sideline. A house at
  * each end (the 12-, 8- and 4-foot circles and the button), the tee, back, hog and centre lines, the hacks, and, in World Curling's, the
@@ -22,7 +37,8 @@ export function curling(o, look) {
     const hogW = spec.lineWidths.hog;
     const board = 0.7;
     let defs = "";
-    let base = el("rect", { class: ft(o, "apron", "ky-apron"), x: -m, y: -m, width: L + 2 * m, height: W + 2 * m });
+    const apron = (x, y, w, h) => el("rect", { class: ft(o, "apron", "ky-apron"), x, y, width: w, height: h });
+    let base = "";
     base += el("path", { class: ft(o, "boards", "ky-boards"), "fill-rule": "evenodd", d: `M${num(-board)} ${num(-board)}H${num(L + board)}V${num(W + board)}H${num(-board)}ZM0 0V${num(W)}H${num(L)}V0Z` });
     base += el("rect", { class: ft(o, "ice", "ky-surface"), x: 0, y: 0, width: L, height: W });
     if (look.pebble) {
@@ -70,10 +86,20 @@ export function curling(o, look) {
             lines += el("path", { class: ft(o, "courtesy-lines", "ky-line"), d: xs.map((x) => `M${num(x)} 0v${num(c.length)}M${num(x)} ${num(W)}v${num(-c.length)}`).join(""), "stroke-width": lineW, fill: "none" });
         }
     }
-    // What is in view: all of the sheet, the half from the hog line to the back line, or the house, at one end.
+    // What is in view: all of the sheet, the half from the hog line to the back line, or the house, at one end; or all of it with its two houses enlarged beside it.
     const along = 1.5;
     let view0 = { x: -m, y: -m, w: L + 2 * m, h: W + 2 * m };
     const left = look.end !== "right";
+    const folded = look.show === "folded" ? foldPlan(spec, [tl, tr], { panels: look.fold?.panels ?? "half", fit: look.fold?.fit ?? 1, margin: m, turned: o.portrait, id: o.id }) : undefined;
+    if (folded !== undefined) {
+        view0 = folded.view;
+        base = `${apron(view0.x, view0.y, view0.w, view0.h)}${base}${foldCopies(folded, base)}`;
+        lines = `${lines}${foldCopies(folded, lines)}${foldLinks(folded, W)}`;
+        defs += foldClips(folded);
+    }
+    else {
+        base = apron(-m, -m, L + 2 * m, W + 2 * m) + base;
+    }
     if (look.show === "half" || look.show === "house") {
         const outer = look.show === "half" ? spec.hogLine + hogW : twelve;
         const x0 = left ? tl - spec.backLine - along : tr - outer - along;
@@ -96,7 +122,15 @@ export function curling(o, look) {
     };
     surface.lineRef = { width: lineW, feet: 1 };
     surface.box = { x: 0, y: 0, w: L, h: W };
-    if (o.landmarks === true) {
+    // A pageant: a picture in each house, the emblem in the middle of the sheet.
+    surface.pageant = { left: { cx: tl, cy, w: twelve * 2, h: twelve * 2, disc: twelve * 2 }, right: { cx: tr, cy, w: twelve * 2, h: twelve * 2, disc: twelve * 2 }, centre: { cx: L / 2, cy, r: W * 0.42 } };
+    if (folded !== undefined) {
+        // The panels hold the data of the strip again, larger; the labels go over it.
+        surface.panels = folded.panels.map((p) => ({ transform: p.transform, clip: p.clip }));
+        surface.over = foldLabels(folded, look.fold?.labels ?? ["", ""], o.portrait);
+        surface.folded = true;
+    }
+    if (o.landmarks === true && folded === undefined) {
         const marks = [
             { id: "hog-line", x: tl + spec.hogLine + hogW / 2, y: 0, side: "top" },
             { id: "hog-line", x: tr - spec.hogLine - hogW / 2, y: 0, side: "top" },

package/dist/surfaces/dive.d.ts

@@ -0,0 +1,9 @@
+import type { DivePlan } from "../pool.ts";
+import { type PoolCtx } from "../pool.kit.ts";
+import { type BuildOptions, type Surface } from "./surface.ts";
+/**
+ * A diving well seen from above, from World Aquatics' rules (Part Four, Article 15 and Appendix 2): the pool wall the boards stand at on the left, the diving direction towards the right. Every springboard is 4.88 m
+ * long and 0.50 m wide with its front edge, the plummet, 2.22 m beyond the wall; each platform has the length and width of the table, its front edge 0.75 to 1.50 m beyond the wall (15.4.9); the boards stand the preferred
+ * distance (Appendix 2, B and C) from the side wall and from each other. The three lines across the well (15.6.3.1) are 21 m long, 2.5 m apart, the first under the plummet of the 3 m springboard.
+ */
+export declare function diving(o: BuildOptions, plan: DivePlan, ctx?: PoolCtx): Surface;