@johnmorrisdotca/dougu-sports 0.7.2 → 0.9.0

package/dist/emblems/ball/ball.engine.js

@@ -1,9 +1,9 @@
 // The ball renderer: one procedural engine for every sphere and every prolate ball. A ball is drawn in true 3D: a rotation, an orthographic projection, back faces dropped, panels cut at the limb
 // along the limb itself, then radial-gradient shading and a grain that stays where it is while the ball turns. A ball is a `BallSpec`: its shape (the semi-axes of an ellipsoid), its
 // view, its material and a `draw` function that lays panels, seams and dots on the unit sphere; the engine does the rest.
-import { grainDef, escape, hashOf, labelled, mix, num, radians, resolveOptions, wrapPiece } from "./ball.core.js";
+import { grainDef, hasPrint, blend, escape, hashOf, labelled, mix, num, radians, resolveOptions, wrapPiece } from "./ball.core.js";
 import { add, apply, basis, cross, dot, ellipseOf, len, mul, norm, rotation, sampleRing, sub } from "./ball.math.js";
-const EPS = 1e-6;
+export const EPS = 1e-6;
 const STEP = Math.PI / 18;
 /** How a point of the unit sphere is carried to the ball's surface: an ellipsoid's scaling, and for a pointed ball a narrowing of the cross-section toward the ends. */
 const shapeOf = (g, u) => {
@@ -11,7 +11,7 @@ const shapeOf = (g, u) => {
     return [u[0] * g.axes[0], u[1] * g.axes[1] * f, u[2] * g.axes[2] * f];
 };
 /** How squarely a point of the sphere faces the eye, before it is scaled: above 0 is the side you see. For an ellipsoid it is the dot of the point with `w`; for a pointed ball the surface's normal is worked out. */
-const visOf = (g, u) => {
+export const visOf = (g, u) => {
     if (g.point === undefined)
         return dot(u, g.w);
     const rest = Math.max(0, 1 - u[0] * u[0]);
@@ -20,7 +20,7 @@ const visOf = (g, u) => {
     const nx = 2 * b * g.point * u[0] * rest ** (g.point - 0.5);
     return (g.rz[0] * nx + g.rz[1] * a * u[1] + g.rz[2] * a * u[2]) / (a * b);
 };
-const project = (g, u) => {
+export const project = (g, u) => {
     const q = apply(g.rot, shapeOf(g, u));
     return [g.cx + g.k * q[0], g.cy - g.k * q[1]];
 };
@@ -82,7 +82,7 @@ function limbArc(g, from, to) {
     return out;
 }
 /** The parts of a curve that face you, each as screen points with their facing. The curve is cut exactly at the limb. */
-function visibleRuns(g, pts, closed) {
+export function visibleRuns(g, pts, closed) {
     const n = pts.length;
     const vis = pts.map((p) => visOf(g, p) / g.wl);
     const at = (u, f) => {
@@ -130,9 +130,34 @@ function visibleRuns(g, pts, closed) {
     }
     return runs;
 }
-const pathOf = (pts) => pts.map((p, i) => `${i === 0 ? "M" : "L"}${num(p[0])} ${num(p[1])}`).join("");
+export const pathOf = (pts, digits = 1) => pts.map((p, i) => `${i === 0 ? "M" : "L"}${num(p[0], digits)} ${num(p[1], digits)}`).join("");
+/** A number written as short as SVG allows: no leading zero, and the space left out where the next number's own sign or point shows where it starts. */
+const tight = (text, after) => {
+    const t = text.replace(/^(-?)0\./, "$1.");
+    return after === "" || t.startsWith("-") || (t.startsWith(".") && after.includes(".")) ? t : ` ${t}`;
+};
+/** A run as a path of relative moves in `digits` decimals, written tight: about half the bytes of `pathOf`. Each step is the difference of the rounded points, so the line does not drift. */
+function relativePath(pts, digits) {
+    const r = (v) => Math.round(v * 10 ** digits) / 10 ** digits;
+    const first = pts[0];
+    let x = r(first[0]), y = r(first[1]);
+    let out = `M${num(x, digits)} ${num(y, digits)}l`;
+    let last = "";
+    for (let i = 1; i < pts.length; i++) {
+        const p = pts[i];
+        const nx = r(p[0]), ny = r(p[1]);
+        for (const v of [nx - x, ny - y]) {
+            const t = tight(num(v, digits), last);
+            out += t;
+            last = t.trim();
+        }
+        x = nx;
+        y = ny;
+    }
+    return out;
+}
 /** A curve's visible parts as paths: a stroke is thinner where it turns toward the limb (three steps), so it does not sit on the ball like a wire. */
-function runPaths(runs, colour, width, extra) {
+function runPaths(runs, colour, width, extra, digits = 1) {
     const tiers = [[], [], []];
     const factor = [1, 0.74, 0.5];
     const tierOf = (f) => (f > 0.55 ? 0 : f > 0.25 ? 1 : 2);
@@ -141,7 +166,7 @@ function runPaths(runs, colour, width, extra) {
         let piece = [];
         const flush = () => {
             if (piece.length > 1)
-                tiers[kind].push(pathOf(piece));
+                tiers[kind].push(digits > 1 ? relativePath(piece, digits) : pathOf(piece, digits));
             piece = [];
         };
         for (const p of run.pts) {
@@ -159,7 +184,7 @@ function runPaths(runs, colour, width, extra) {
     const make = (d, w) => (d.length === 0 ? "" : `<path d="${d.join("")}" fill="none" stroke="${colour}" stroke-width="${num(w, 2)}" stroke-linecap="round" stroke-linejoin="round"${extra}/>`);
     return make(tiers[2], width * factor[2]) + make(tiers[1], width * factor[1]) + make(tiers[0], width);
 }
-function surfaceOf(g, line, minWidth) {
+function surfaceOf(g, line, minWidth, home) {
     const INK = "currentColor";
     const facing = (u) => visOf(g, u) / g.wl;
     const s = {
@@ -181,7 +206,7 @@ function surfaceOf(g, line, minWidth) {
             const d = ringPath(g, sampleRing(ring, o?.n ?? 4));
             if (d === "")
                 return "";
-            return `<path d="${d}" fill="${line ? INK : fill}"${o?.opacity === undefined ? "" : ` opacity="${o.opacity}"`}/>`;
+            return `<path d="${d}" fill="${line ? INK : fill}"${o?.rule === undefined ? "" : ` fill-rule="${o.rule}"`}${o?.opacity === undefined ? "" : ` opacity="${o.opacity}"`}/>`;
         },
         panels(rings, fill, o) {
             if (line && o?.ink !== true)
@@ -189,8 +214,16 @@ function surfaceOf(g, line, minWidth) {
             const d = rings.map((ring) => ringPath(g, sampleRing(ring, o?.n ?? 4))).join("");
             if (d === "")
                 return "";
-            return `<path d="${d}" fill="${line ? INK : fill}"${o?.opacity === undefined ? "" : ` opacity="${o.opacity}"`}/>`;
+            return `<path d="${d}" fill="${line ? INK : fill}"${o?.rule === undefined ? "" : ` fill-rule="${o.rule}"`}${o?.opacity === undefined ? "" : ` opacity="${o.opacity}"`}/>`;
         },
+        fill(colour) {
+            if (line)
+                return "";
+            const sil = silhouette(g);
+            return sil.d === "" ? `<circle ${sil.tag} fill="${colour}"/>` : `<path d="${sil.d}" fill="${colour}"/>`;
+        },
+        view: g,
+        home,
         stroke: (pts, colour, width, o) => s.strokes([pts], colour, width, o),
         strokes(curves, colour, width, o) {
             if (line && (o?.deco === true || o?.ink === false))
@@ -199,7 +232,7 @@ function surfaceOf(g, line, minWidth) {
             if (runs.length === 0)
                 return "";
             const extra = `${o?.opacity === undefined || line ? "" : ` opacity="${o.opacity}"`}${o?.dash === undefined ? "" : ` stroke-dasharray="${o.dash}"`}${o?.dx === undefined && o?.dy === undefined ? "" : ` transform="translate(${o.dx ?? 0} ${o.dy ?? 0})"`}`;
-            return runPaths(runs, line ? INK : colour, Math.max(width, minWidth), extra);
+            return runPaths(runs, line ? INK : colour, Math.max(width, minWidth), extra, o?.digits);
         },
         seam(pts, colour, width, o) {
             if (line)
@@ -297,11 +330,15 @@ export function drawBall(title, key, spec, opts, turn, turning) {
     const g = { ox, oy, cx: ox + kk * away[0], cy: oy - kk * away[1], axes, rot, k: (46 * (spec.fit ?? 1)) / Math.max(...axes), w, wl: len(w), rz, point: spec.point };
     const line = opts.style === "line";
     const minWidth = 80 / opts.size;
-    const base = opts.tint ?? spec.base;
-    const surface = surfaceOf(g, line, minWidth);
-    const layers = spec.draw(surface, base, opts.accent, opts.colors);
+    // A ball with a second colour of its own (a soccer ball's panels on a white ground) paints the body as the ground and the second colour as the panels; one with a single colour takes the body as its main colour.
+    const paint = opts.paint;
+    const two = spec.ground !== undefined;
+    const base = opts.tint ?? (two ? paint?.second : paint?.body) ?? spec.base;
+    const ground = two ? paint?.body ?? spec.ground : undefined;
+    const surface = surfaceOf(g, line, minWidth, homeOf(spec));
+    const layers = spec.draw(surface, base, opts.accent, opts.colors, { paint: opts.paint, print: opts.print, printer: opts.printer });
     const sil = silhouette(g);
-    const id = `k${hashOf(`${key}|${opts.style}|${opts.tint ?? ""}|${opts.accent ?? ""}${opts.colors === undefined ? "" : `|${opts.colors.join("")}`}|${sil.tag}${sil.d}`)}`;
+    const id = `k${hashOf(`${key}|${opts.style}|${opts.tint ?? ""}|${opts.accent ?? ""}${opts.colors === undefined ? "" : `|${opts.colors.join("")}`}|${sil.tag}${sil.d}${paint === undefined && (opts.print === undefined || opts.printer === undefined) ? "" : `|${JSON.stringify([paint, opts.printer === undefined ? undefined : opts.print])}`}`)}`;
     // A long outline (the hull of a pointed ball) is written once, in the definitions, and used wherever the silhouette is.
     const long = sil.d.length > 400;
     const outline = long ? `<path id="${id}s" d="${sil.d}"/>` : "";
@@ -312,7 +349,8 @@ export function drawBall(title, key, spec, opts, turn, turning) {
         return wrapPiece({ title, size: opts.size, theme: opts.theme, defs: outline, body: `<g fill="none" stroke-linecap="round" stroke-linejoin="round">${body}</g>` });
     }
     const m = spec.mat;
-    const shade = m.shade ?? mix(base, -0.62);
+    const painted = paint?.body !== undefined || paint?.second !== undefined;
+    const shade = painted && !two ? mix(paint?.second === undefined || paint.body === undefined ? base : blend(paint.body, paint.second, 0.5), -0.6) : m.shade ?? mix(base, -0.62);
     const grain = opts.grain ?? (opts.size >= 48 && !turning);
     const gr = grain && m.grain !== undefined ? m.grain : undefined;
     const rim = m.rim ?? 1;
@@ -325,17 +363,29 @@ export function drawBall(title, key, spec, opts, turn, turning) {
         (gr === undefined
             ? ""
             : grainDef(id, gr.f, gr.a, gr.seed));
-    const inner = `<g clip-path="url(#${id}c)"${gr === undefined ? "" : ` filter="url(#${id}n)"`}>${shape(`fill="${spec.ground ?? base}"`)}${layers}</g>`;
+    const inner = `<g clip-path="url(#${id}c)"${gr === undefined ? "" : ` filter="url(#${id}n)"`}>${shape(`fill="${ground ?? spec.ground ?? base}"`)}${layers}</g>`;
     const metal = m.metal === true ? shape(`fill="url(#${id}m)"`) : "";
     const overlays = shape(`fill="url(#${id}d)"`) + metal + shape(`fill="url(#${id}b)"`) + shape(`fill="url(#${id}h)"`);
     const at = spec.attach?.(surface, base);
     return wrapPiece({ title, size: opts.size, theme: opts.theme, defs: defs + metalDef(id, m.metal === true), body: `${at?.behind ?? ""}${inner}${overlays}${at?.front ?? ""}` });
 }
+/** A ball's label area as a surface sees it: the middle, the right-hand and the upward direction, orthogonal, and how far it reaches. */
+function homeOf(spec) {
+    const h = spec.home;
+    if (h === undefined)
+        return undefined;
+    const c = norm(h.c);
+    const ex = norm(cross(h.up, c));
+    return { c, ex, up: cross(c, ex), reach: h.reach };
+}
 const finite = (v) => (typeof v === "number" && Number.isFinite(v) ? v : 0);
 /** A ball from its definition: the `Piece` the registry and the gallery take. */
 export function defineBall(def) {
-    const view = def.spec.view;
-    const render = (o, turning) => drawBall(escape(def.en), def.id, def.spec, resolveOptions(o), { yaw: radians(view.yaw + finite(o?.yaw), 0), pitch: radians(view.pitch + finite(o?.pitch), 0), roll: radians(view.roll + finite(o?.roll), 0) }, turning);
+    const render = (o, turning) => {
+        const opts = resolveOptions(o);
+        const view = hasPrint(opts.print) && opts.printer !== undefined && opts.style !== "line" && def.spec.home !== undefined ? def.spec.home.view : def.spec.view;
+        return drawBall(escape(def.en), def.id, def.spec, opts, { yaw: radians(view.yaw + finite(o?.yaw), 0), pitch: radians(view.pitch + finite(o?.pitch), 0), roll: radians(view.roll + finite(o?.roll), 0) }, turning);
+    };
     return {
         id: def.id,
         en: def.en,

package/dist/emblems/ball/ball.family.seamed.d.ts

@@ -34,5 +34,9 @@ export interface SeamedOptions {
     };
     /** A thin groove along the seam. */
     groove?: string;
+    /** Where the ball takes its logo and lettering (see `BallSpec.home`): a baseball and a softball do. */
+    home?: BallSpec["home"];
 }
+/** The label area of a baseball's or a softball's seam (b = 0.4): the middle of one of its two leather pieces, the way up there, and the view that shows it. The point opposite is in the same leather piece, 0.6 radians clear of the seam, so lettering can go on the far side of the ball. */
+export declare const SEAMED_HOME: (word: string) => NonNullable<BallSpec["home"]>;
 export declare function seamedBall(o: SeamedOptions): Piece<BallSpec>;

package/dist/emblems/ball/ball.family.seamed.js

@@ -2,17 +2,44 @@
 // A baseball and a softball have red stitches that cross it in Vs; a tennis or padel ball has a white rubber strip along it; a sliotar a raised rib.
 import { defineBall } from "./ball.engine.js";
 import { mix } from "./ball.core.js";
+import { stitchFor } from "./ball.contrast.js";
+import { region } from "./ball.region.js";
 import { scuffs } from "./ball.decal.js";
-import { seamCurve } from "./ball.math.js";
+import { add, cross, greatCircle, mul, norm, seamCurve } from "./ball.math.js";
 import { stitches } from "./ball.stitch.js";
+/** The label area of a baseball's or a softball's seam (b = 0.4): the middle of one of its two leather pieces, the way up there, and the view that shows it. The point opposite is in the same leather piece, 0.6 radians clear of the seam, so lettering can go on the far side of the ball. */
+export const SEAMED_HOME = (word) => ({
+    c: [0.668, -0.669, -0.326],
+    up: [0.601, 0.743, -0.293],
+    reach: 0.82,
+    view: { yaw: -127.8, pitch: -47.4, roll: -7.9 },
+    word,
+});
 export function seamedBall(o) {
     const spec = {
         view: o.view ?? { yaw: 0, pitch: 0, roll: 0 },
         base: o.base,
         mat: o.mat,
-        draw: (s, base) => {
+        home: o.home,
+        draw: (s, base, _accent, _colors, custom) => {
             const seam = seamCurve(o.b, 160);
+            const paint = custom?.paint;
+            const second = paint?.second;
             let out = "";
+            // A two-tone ball: the second colour fills the region on the right of the seam (or a half of the ball), the body colour the rest.
+            if (second !== undefined && !s.line) {
+                if (paint?.split === "half" && o.home !== undefined) {
+                    const c = norm(o.home.c), ex = norm(cross(o.home.up, c));
+                    const turn = ((paint.angle ?? 0) * Math.PI) / 180;
+                    const n = add(mul(ex, Math.cos(turn)), mul(cross(c, ex), Math.sin(turn)));
+                    out += region(s, greatCircle(n, 120), second);
+                }
+                else
+                    out += region(s, [...seam].reverse(), second);
+            }
+            const grounds = second === undefined ? [base] : [base, second];
+            if (custom?.print !== undefined && o.home !== undefined)
+                out += custom.printer?.(s, custom.print, o.home.word, [base]) ?? "";
             if (o.groove !== undefined)
                 out += s.stroke(seam, o.groove, 0.8, { closed: true, opacity: 0.55 });
             if (o.strip !== undefined)
@@ -21,11 +48,19 @@ export function seamedBall(o) {
                 out += scuffs(s, mix(base, -0.55), mix(base, 0.6), { dark: o.wear.dark, pale: o.wear.pale, seed: o.wear.seed });
             if (o.stitch !== undefined) {
                 const marks = stitches(seam, true, o.stitch.count, o.stitch.half, { v: true, lean: o.stitch.lean });
-                const second = o.stitch.colour2;
-                if (second === undefined)
-                    out += s.strokes(marks, o.stitch.colour, o.stitch.width, { ink: false });
-                else
-                    out += s.strokes(marks.filter((_, i) => i % 2 === 0), o.stitch.colour, o.stitch.width, { ink: false }) + s.strokes(marks.filter((_, i) => i % 2 === 1), second, o.stitch.width, { ink: false });
+                const colour2 = o.stitch.colour2;
+                if (second !== undefined && paint?.split !== "half") {
+                    // On a ball split along its seam each stitch's two legs lie on their own colour, and take the thread that shows on it.
+                    const legs = (pick) => marks.map((m) => (pick === 0 ? [m[0], m[1]] : [m[1], m[2]]));
+                    out += s.strokes(legs(0), stitchFor([base], paint?.stitch, o.stitch.colour), o.stitch.width, { ink: false }) + s.strokes(legs(1), stitchFor([second], paint?.stitch, o.stitch.colour), o.stitch.width, { ink: false });
+                }
+                else {
+                    const colour = stitchFor(grounds, paint?.stitch, o.stitch.colour);
+                    if (colour2 === undefined || colour !== o.stitch.colour)
+                        out += s.strokes(marks, colour, o.stitch.width, { ink: false });
+                    else
+                        out += s.strokes(marks.filter((_, i) => i % 2 === 0), colour, o.stitch.width, { ink: false }) + s.strokes(marks.filter((_, i) => i % 2 === 1), colour2, o.stitch.width, { ink: false });
+                }
             }
             if (o.strip === undefined && o.stitch === undefined)
                 out += s.stroke(seam, "currentColor", 1.6, { closed: true });

package/dist/emblems/ball/ball.image.d.ts

@@ -3,6 +3,14 @@ export interface SafeImage {
     /** x, y, width and height of the drawing's own coordinates (its viewBox). */
     box: readonly [number, number, number, number];
     markup: string;
+    /** The same drawing as a list of elements in order, with the attributes that survived (ids already renamed), for a caller that draws it its own way (`ball.warp.ts` wraps it onto a sphere). */
+    nodes: readonly SafeNode[];
+}
+/** One element of a safe drawing: opened (`open`), closed (`close`) or both at once (`self`), with its safe attributes. */
+export interface SafeNode {
+    kind: "open" | "close" | "self";
+    name: string;
+    attrs: Readonly<Record<string, string>>;
 }
 /** The markup of an SVG made safe, or `undefined` when there is none to be had: not text, too long, no `<svg>` root, nothing drawable left. `prefix` is put in front of every id and every reference to one. */
 export declare function safeImage(source: unknown, prefix: string): SafeImage | undefined;

package/dist/emblems/ball/ball.image.js

@@ -54,6 +54,7 @@ export function safeImage(source, prefix) {
     const cleaned = source.replace(/<!--[\s\S]*?-->/g, "").replace(/<!\[CDATA\[[\s\S]*?\]\]>/g, "").replace(/<\?[\s\S]*?\?>/g, "").replace(/<![^>]*>/g, "");
     const tag = /<(\/?)([A-Za-z][\w:-]*)((?:[^>"']|"[^"]*"|'[^']*')*?)(\/?)>/g;
     let out = "";
+    const list = [];
     let nodes = 0;
     let root;
     // The depth inside an element being dropped (0 when none is).
@@ -73,8 +74,10 @@ export function safeImage(source, prefix) {
         }
         if (closing) {
             const top = open.pop();
-            if (top !== undefined && top !== "#root")
+            if (top !== undefined && top !== "#root") {
                 out += `</${top}>`;
+                list.push({ kind: "close", name: top, attrs: {} });
+            }
             continue;
         }
         const attrs = {};
@@ -98,6 +101,7 @@ export function safeImage(source, prefix) {
         if (attrs["style"] !== undefined)
             pairs.push(...styleAttrs(attrs["style"]));
         let written = "";
+        const kept = {};
         const seen = new Set();
         for (const [key, raw] of pairs) {
             if (!ATTRS.has(key) || seen.has(key))
@@ -106,8 +110,10 @@ export function safeImage(source, prefix) {
             if (v === undefined)
                 continue;
             seen.add(key);
+            kept[key] = v;
             written += ` ${key}="${escape(v)}"`;
         }
+        list.push({ kind: selfClosed ? "self" : "open", name, attrs: kept });
         out += `<${name}${written}${selfClosed ? "/>" : ">"}`;
         if (!selfClosed)
             open.push(name);
@@ -115,8 +121,11 @@ export function safeImage(source, prefix) {
     if (root === undefined || !/<(path|circle|ellipse|rect|line|polyline|polygon)\b/.test(out))
         return undefined;
     // Close what the text left open, so the markup is always balanced.
-    for (let top = open.pop(); top !== undefined; top = open.pop())
-        if (top !== "#root")
-            out += `</${top}>`;
-    return { box: boxOf(root), markup: out };
+    for (let top = open.pop(); top !== undefined; top = open.pop()) {
+        if (top === "#root")
+            continue;
+        out += `</${top}>`;
+        list.push({ kind: "close", name: top, attrs: {} });
+    }
+    return { box: boxOf(root), markup: out, nodes: list };
 }

package/dist/emblems/ball/ball.index.js

@@ -1,6 +1,5 @@
 import { escape, num, resolveOptions, PIECE_INK } from "./ball.core.js";
 import { BALL_AFL } from "./ball.afl.js";
-import { BALL_BASEBALL } from "./ball.baseball.js";
 import { BALL_BASKETBALL } from "./ball.basketball.js";
 import { BALL_BASKETBALL_3X3 } from "./ball.basketball3x3.js";
 import { BALL_BASKETBALL_6 } from "./ball.basketball6.js";
@@ -17,16 +16,15 @@ import { BALL_PADEL } from "./ball.padel.js";
 import { BALL_PICKLEBALL_OUTDOOR, BALL_PICKLEBALL_INDOOR } from "./ball.pickleball.js";
 import { BALL_PUCK } from "./ball.puck.js";
 import { PUCKS } from "./ball.puck.print.js";
+import { BALL_BASEBALL, BALL_SOCCER, BALL_SOCCER_COLOUR, BALL_SOCCER_ORANGE, BALL_SOCCER_YELLOW, BALL_SOFTBALL } from "./ball.printable.js";
 import { BALL_ROUNDNET } from "./ball.roundnet.js";
 import { BALL_RUGBY } from "./ball.rugby.js";
 import { BALL_SEPAK_TAKRAW } from "./ball.sepaktakraw.js";
 import { BALL_SHUTTLECOCK_FEATHER, BALL_SHUTTLECOCK_NYLON } from "./ball.shuttlecock.js";
 import { BALL_SLIOTAR } from "./ball.sliotar.js";
 import { BALL_LACROSSE, BALL_RACQUETBALL, BALL_TABLE_TENNIS, BALL_SHOT } from "./ball.smooth.js";
-import { BALL_SOCCER, BALL_SOCCER_COLOUR } from "./ball.soccer.js";
-import { BALL_SOCCER_26, BALL_SOCCER_18, BALL_SOCCER_14, BALL_SOCCER_12, BALL_SOCCER_6, BALL_SOCCER_ORANGE, BALL_SOCCER_26_ORANGE, BALL_SOCCER_18_ORANGE, BALL_SOCCER_14_ORANGE, BALL_SOCCER_12_ORANGE, BALL_SOCCER_6_ORANGE, BALL_SOCCER_YELLOW, BALL_SOCCER_26_YELLOW, BALL_SOCCER_18_YELLOW, BALL_SOCCER_14_YELLOW, BALL_SOCCER_12_YELLOW, BALL_SOCCER_6_YELLOW } from "./ball.soccer.panels.js";
+import { BALL_SOCCER_26, BALL_SOCCER_18, BALL_SOCCER_14, BALL_SOCCER_12, BALL_SOCCER_6, BALL_SOCCER_26_ORANGE, BALL_SOCCER_18_ORANGE, BALL_SOCCER_14_ORANGE, BALL_SOCCER_12_ORANGE, BALL_SOCCER_6_ORANGE, BALL_SOCCER_26_YELLOW, BALL_SOCCER_18_YELLOW, BALL_SOCCER_14_YELLOW, BALL_SOCCER_12_YELLOW, BALL_SOCCER_6_YELLOW } from "./ball.soccer.panels.js";
 import { BALL_FUTSAL, BALL_BEACH_SOCCER } from "./ball.soccer.indoor.js";
-import { BALL_SOFTBALL } from "./ball.softball.js";
 import { BALL_SOCCER_1870_HAND_STITCHED, BALL_SOCCER_1900_LACED, BALL_SOCCER_1930_18_PANEL, BALL_SOCCER_1950_12_PANEL, BALL_SOCCER_1960_32_PANEL_LEATHER } from "./ball.soccer.vintage.js";
 import { BALL_SOCCER_1970_BLACK_WHITE, BALL_SOCCER_1978_TRIAD, BALL_SOCCER_1986_DECORATED_TRIAD, BALL_SOCCER_1998_COLOURED_TRIAD, BALL_SOCCER_2002_TRIANGLE_SWEEP, BALL_SOCCER_2006_PROPELLER, BALL_SOCCER_2010_GROOVED, BALL_SOCCER_2014_RIBBON, BALL_SOCCER_2018_PIXEL, BALL_SOCCER_2022_SPEED_SHELL, BALL_SOCCER_TRAINING_HIGH_VIS } from "./ball.soccer.era.js";
 import { BALL_SOCCER_STARS_BLUE, BALL_SOCCER_STARS_RED, BALL_SOCCER_STARS_NIGHT, BALL_SOCCER_HEXAGONS_CYAN, BALL_SOCCER_HEXAGONS_MAGENTA, BALL_SOCCER_HEXAGONS_LIME, BALL_SOCCER_FLAMES_FIRE, BALL_SOCCER_FLAMES_ICE, BALL_SOCCER_FLAMES_TOXIC, BALL_SOCCER_CHEVRONS_RED, BALL_SOCCER_CHEVRONS_GREEN, BALL_SOCCER_CHEVRONS_BLUE, BALL_SOCCER_SWIRL_BLUE, BALL_SOCCER_SWIRL_RED, BALL_SOCCER_SWIRL_TEAL, BALL_SOCCER_METALLIC_GOLD, BALL_SOCCER_METALLIC_SILVER, BALL_SOCCER_METALLIC_COBALT } from "./ball.soccer.store.js";

package/dist/emblems/ball/ball.letters.d.ts

@@ -22,6 +22,7 @@ export interface Lettering {
 export declare function textWidth(text: string, o: Lettering): number;
 /** The size at which a text is as wide as `width` at most and as tall as `height` at most. */
 export declare function fitSize(text: string, o: Omit<Lettering, "size">, width: number, height: number): number;
+type Pt = readonly [number, number];
 /** A line of text on a straight line, centred on (`x`, `y`), as one path: draw it with a stroke of `weight * size`. */
 export declare function linePath(text: string, o: Lettering, x: number, y: number): string;
 /**
@@ -29,4 +30,6 @@ export declare function linePath(text: string, o: Lettering, x: number, y: numbe
  * clockwise (the top of the ring); with `inside` true they stand inward and read left to right (the bottom of the ring, `centre` 180). One path.
  */
 export declare function arcPath(text: string, o: Lettering, r: number, centre: number, inside?: boolean): string;
+/** The centre lines of a text on a straight line, centred on (`x`, `y`), as lists of points (curves sampled `steps` to a segment), for a caller that carries them onto a surface; draw them with a stroke of `weight * size`. */
+export declare function lineStrokes(text: string, o: Lettering, x: number, y: number, steps?: number): Pt[][];
 export {};

package/dist/emblems/ball/ball.letters.js

@@ -140,3 +140,54 @@ export function arcPath(text, o, r, centre, inside = false) {
         });
     }).join("");
 }
+/** The centre lines of a text on a straight line, centred on (`x`, `y`), as lists of points (curves sampled `steps` to a segment), for a caller that carries them onto a surface; draw them with a stroke of `weight * size`. */
+export function lineStrokes(text, o, x, y, steps = 6) {
+    const glyphs = glyphsOf(text);
+    const s = setting(glyphs, o);
+    const k = o.size / GLYPH_H;
+    const left = x - (s.total * k) / 2;
+    const top = y - o.size / 2;
+    const shape = shaped(o);
+    const out = [];
+    glyphs.forEach((g, i) => {
+        let cur = [];
+        let at = [0, 0];
+        let start = [0, 0];
+        const put = (p) => {
+            const q = shape(p);
+            cur.push([left + (s.at[i] + q[0]) * k, top + q[1] * k]);
+        };
+        const flush = () => {
+            if (cur.length > 1)
+                out.push(cur);
+            cur = [];
+        };
+        for (const part of g.d.match(/[MLCZ][^MLCZ]*/g) ?? []) {
+            const n = (part.slice(1).match(/-?\d+(?:\.\d+)?/g) ?? []).map(Number);
+            if (part[0] === "M") {
+                flush();
+                at = start = [n[0], n[1]];
+                put(at);
+            }
+            else if (part[0] === "L") {
+                at = [n[0], n[1]];
+                put(at);
+            }
+            else if (part[0] === "C") {
+                const [x1, y1, x2, y2, x3, y3] = n;
+                const [x0, y0] = at;
+                for (let j = 1; j <= steps; j++) {
+                    const t = j / steps, u = 1 - t;
+                    put([u * u * u * x0 + 3 * u * u * t * x1 + 3 * u * t * t * x2 + t * t * t * x3, u * u * u * y0 + 3 * u * u * t * y1 + 3 * u * t * t * y2 + t * t * t * y3]);
+                }
+                at = [x3, y3];
+            }
+            else {
+                at = start;
+                put(at);
+            }
+        }
+        flush();
+    });
+    return out;
+}

package/dist/emblems/ball/ball.print.d.ts

@@ -0,0 +1,81 @@
+import { type Piece } from "./ball.core.ts";
+import { type PrintOptions } from "./ball.core.ts";
+import type { BallSpec, Surface } from "./ball.engine.ts";
+/** The colours of a painted ball: `body` is the ball (or a soccer ball's hexagons), `second` the other half of a two-tone ball (or a soccer ball's pentagons). */
+export interface BallPaint {
+    /** The ball's colour: `#rgb`, `#rrggbb` or `rgb()`; anything else is ignored. */
+    body?: string;
+    /** The second colour. A baseball or a softball becomes two-tone, split along its seam or in halves; a soccer ball's pentagons take it. */
+    second?: string;
+    /** How a two-tone baseball or softball is divided: `"seam"` (the default: the figure-eight seam parts the two colours, as a commemorative ball is) or `"half"` (a flat cut through the middle). */
+    split?: "seam" | "half";
+    /** For `split: "half"`: the turn of the cut in degrees about the label's middle (0 is a vertical cut, body on the left). */
+    angle?: number;
+    /** The colour of the stitches. By default one that shows against the ball (red, cream or navy; on a two-tone ball each stitch's legs are the colour that shows on their own side). */
+    stitch?: string;
+}
+/** A place on the ball in degrees from the middle of its default view: `lon` toward the right, `lat` toward the top, in the ball's own frame (it turns with the ball). */
+export interface Spot {
+    lon?: number;
+    lat?: number;
+}
+/** Where the logo and the lettering go, as a place on the ball in degrees from the middle of its default view. By default the logo is there and so is the lettering, or the lettering is on the far side of the ball (`lon: 180`) when there is a logo. */
+export interface BallSpots {
+    decal?: Spot;
+    label?: Spot;
+}
+/** A logo printed on the ball. */
+export interface BallDecal {
+    /** An SVG string. It is made safe first (only shapes, gradients and groups survive; no script, text, image, style or address), a gradient is its mean colour, and it is wrapped exactly onto the sphere. */
+    svg?: string;
+    /** Or a `data:` URI of an image: an SVG is read as `svg` is, a PNG, JPEG, GIF or WebP is laid on in small triangles (close, not exact). An address on the network is refused. */
+    href?: string;
+    /** How wide the logo is, in degrees of the sphere (about 55 by default). */
+    size?: number;
+    /** A turn of the logo on the ball, in degrees. */
+    turn?: number;
+}
+/** The stamp: lines of bold block lettering, the first with a small star on each side, and an optional signature-style line under them. */
+export interface BallStamp {
+    /** The lines (up to three, 24 letters each, any letter, digit or `- . , ' / : &`; the ball's own default is `UNOFFICIAL` and `DIGITAL BASEBALL`). */
+    lines?: readonly string[];
+    /** Stars on each side of the first line (on by default). */
+    stars?: boolean;
+    /** A made-up signature under the lines: `true`, a seed (text or a number), or `{ seed, caption }` with a small line of words under it. The same seed always draws the same squiggle, and no seed is anyone's real hand. */
+    sign?: boolean | string | number | {
+        seed?: string | number;
+        caption?: string;
+    };
+    /** The ink, `#rgb`, `#rrggbb` or `rgb()`. Navy by default, or white or black where navy would not show on the ball. */
+    colour?: string;
+}
+/** The cursive word where a maker's mark would sit. */
+export interface BallScript {
+    /** The word (up to 16 letters; a-z and a space; a capital without a drawing of its own is a tall small letter). By default the ball's own: `Baseball`, `Softball` or `Soccer`. */
+    text?: string;
+    colour?: string;
+}
+/** The small mark under the script: a letter in a circle, or a mark of your own. */
+export interface BallMark {
+    /** The letter in the circle (one letter or digit). By default the first letter of the script. */
+    letter?: string;
+    /** A mark of your own as an SVG string (made safe first, as a decal is), fitted in the circle's place. It replaces the circled letter. */
+    svg?: string;
+    /** Or a `data:` URI of an SVG (a raster picture is not taken for a mark). */
+    href?: string;
+    colour?: string;
+}
+/** The ink for a print on the given grounds: the wanted colour if it shows on all of them (3 to 1), else the first of navy, white and near-black that does. */
+export declare function inkFor(grounds: readonly string[], wanted?: string): string;
+/**
+ * The print of a ball as layers for its surface: the logo, then the label (the script, the circled letter, the stamp), each at its own place. `grounds` are the colours the print lies on, for the ink (the label's far side is the same colour as the front on every ball that has one). A ball
+ * in the line style has none. Returns an empty string when nothing was asked for.
+ */
+export declare function printLayers(s: Surface, p: PrintOptions | undefined, word: string, grounds: readonly string[]): string;
+/** What `printLayers` was given, for the id of a drawing (so two prints of one ball have their own definitions). */
+export declare const printKey: (p: PrintOptions | undefined) => string;
+/**
+ * A ball that can be printed. The balls themselves carry no printing code (a ball bundled alone stays small): `renderEmblem` and the registry use this, and so can you for one ball taken from its own module:
+ * `const ball = printed(BALL_BASEBALL); ball.svg({ stamp: true })`. The same ball with the printer in its options; options that ask for no print draw exactly what the plain ball draws.
+ */
+export declare const printed: <P extends Piece<BallSpec>>(piece: P) => P;