@logomarks/core 0.1.11 → 0.2.1

package/src/forms/geo.js

@@ -0,0 +1,233 @@
+/**
+ * Bold geometric parts: needle gaps that taper to nothing, knobs and dials, roof-tile scales laid back to front, half
+ * discs and a disc split along a line with each half's rim moved. Every part is on the 512 canvas, centred on C. From the
+ * Logomarks tools (geoparts.mjs, batch 212, "Bold · Geometric", and its editions in batch 220).
+ */
+import { C, D, I, U, circle, grown, over, polar, poly, rect, rot, stroke } from '../geometry/index.js';
+
+/** @typedef {import('../geometry/types.js').Point} Point */
+/** @typedef {import('../geometry/types.js').Polygon} Polygon */
+/** @typedef {import('../geometry/types.js').Shape} Shape */
+/** @typedef {import('../geometry/types.js').Geom} Geom */
+
+/** The base square's side. */
+export const GEO_SQ = 420;
+
+/** The base square's left edge. */
+export const GEO_X0 = C - GEO_SQ / 2;
+
+/** The base square's right edge. */
+export const GEO_X1 = C + GEO_SQ / 2;
+
+/**
+ * The base square, side s, centred on the canvas.
+ *
+ * @param {number} [s=GEO_SQ] Its side.
+ * @returns {Polygon} The square.
+ */
+export const sq = (s = GEO_SQ) => rect(C - s / 2, C - s / 2, s, s);
+
+/**
+ * The unit vector from a to b, and the distance between them.
+ *
+ * @param {readonly number[]} a From.
+ * @param {readonly number[]} b To.
+ * @returns {[Point, number]} The direction and the length.
+ */
+export const dirOf = (a, b) => { const L = Math.hypot(b[0] - a[0], b[1] - a[1]); return [[(b[0] - a[0]) / L, (b[1] - a[1]) / L], L]; };
+
+/**
+ * A needle gap from a (width w0) to b (width w1), run on past b by `ext` at the same taper, and back past a by 2, so a
+ * zero-width tip still parts the corner cleanly.
+ *
+ * @param {readonly number[]} a The start.
+ * @param {readonly number[]} b Where the taper is measured to.
+ * @param {number} w0 The width at a.
+ * @param {number} w1 The width at b.
+ * @param {number} [ext=300] How far it runs on past b.
+ * @returns {Polygon} The gap, to cut.
+ */
+export const needle = (a, b, w0, w1, ext = 300) => {
+	const [[ux, uy], L] = dirOf(a, b), n = [-uy, ux], w2 = w0 + ((w1 - w0) * (L + ext)) / L;
+	const s = [a[0] - ux * 2, a[1] - uy * 2], e = [a[0] + ux * (L + ext), a[1] + uy * (L + ext)];
+	return poly([[s[0] + (n[0] * w0) / 2, s[1] + (n[1] * w0) / 2], [e[0] + (n[0] * w2) / 2, e[1] + (n[1] * w2) / 2], [e[0] - (n[0] * w2) / 2, e[1] - (n[1] * w2) / 2], [s[0] - (n[0] * w0) / 2, s[1] - (n[1] * w0) / 2]]);
+};
+
+/**
+ * A straight band of width w along a → b, its ends square (make it long enough to clip).
+ *
+ * @param {readonly number[]} a The start.
+ * @param {readonly number[]} b The end.
+ * @param {number} w The width.
+ * @returns {Polygon} The band.
+ */
+export const band = (a, b, w) => {
+	const [[ux, uy]] = dirOf(a, b), n = [(-uy * w) / 2, (ux * w) / 2];
+	return poly([[a[0] + n[0], a[1] + n[1]], [b[0] + n[0], b[1] + n[1]], [b[0] - n[0], b[1] - n[1]], [a[0] - n[0], a[1] - n[1]]]);
+};
+
+/**
+ * The half plane on one side of an open polyline that runs right across a shape: the polyline closed by two points 3000
+ * out along the normal of its first-to-last chord.
+ *
+ * @param {readonly Point[]} L The polyline.
+ * @param {number} s Which side: 1 or −1.
+ * @returns {Polygon} The half plane.
+ */
+export const side = (L, s) => {
+	const a = L[0], b = L.at(-1), [[dx, dy]] = dirOf(a, b), n = [-dy * s * 3000, dx * s * 3000];
+	return poly([...L, [b[0] + n[0], b[1] + n[1]], [a[0] + n[0], a[1] + n[1]]]);
+};
+
+/**
+ * A front strand laid over a closed band where they cross near p: the band is cut free round `front` by g, only inside
+ * the radius R of p.
+ *
+ * @param {Geom} all The band (and anything else under the strand).
+ * @param {Geom} front The strand in front.
+ * @param {readonly number[]} p The crossing.
+ * @param {number} R How far round the crossing the cut reaches.
+ * @param {number} g The gap.
+ * @returns {Shape} The crossing drawn.
+ */
+export const crossOver = (all, front, p, R, g) => U(D(all, I(grown(front, g), circle(...p, R, 120))), front);
+
+/**
+ * A disc, with at least 180 points (two a unit of diameter).
+ *
+ * @param {number} cx The centre.
+ * @param {number} cy The centre.
+ * @param {number} r The radius.
+ * @returns {Polygon} The disc.
+ */
+export const geoDisc = (cx, cy, r) => circle(cx, cy, r, Math.max(180, Math.round(r * 2)));
+
+/**
+ * A knob: a disc of radius r with one slot of width w at `deg` (screen degrees, 0 right, 90 down). `full` splits it along
+ * the whole diameter; otherwise the slot runs from the centre out through the rim (a pointer).
+ *
+ * @param {number} cx The centre.
+ * @param {number} cy The centre.
+ * @param {number} r The radius.
+ * @param {number} deg The slot's angle.
+ * @param {number} w The slot's width.
+ * @param {boolean} [full=true] Split right across, or a pointer.
+ * @returns {Shape} The knob.
+ */
+export const knob = (cx, cy, r, deg, w, full = true) => {
+	const p = polar(r + 30, deg, cx, cy), q = full ? polar(r + 30, deg + 180, cx, cy) : [cx, cy];
+	const slot = full ? band(q, p, w) : U(band(q, p, w), circle(cx, cy, w / 2, 48));
+	return D(geoDisc(cx, cy, r), slot);
+};
+
+/**
+ * Knobs on a grid, centred on the canvas: rows of tokens, each a slot angle (`|` 90, `-` 0, `\` 45, `/` −45, `pN` a
+ * pointer at N degrees, `.` no disc), discs of radius r on a pitch of 2r + g.
+ *
+ * @param {readonly (readonly string[])[]} rows The tokens, row by row.
+ * @param {number} g The gap between discs.
+ * @param {number} w The slot width.
+ * @param {number} r The disc radius.
+ * @returns {Shape} The knobs.
+ */
+export const knobs = (rows, g, w, r) => {
+	const n = Math.max(...rows.map((x) => x.length)), m = rows.length, p = 2 * r + g, out = [];
+	const ang = { '|': 90, '-': 0, '\\': 45, '/': -45 };
+	rows.forEach((row, j) => row.forEach((t, i) => {
+		if (t === '.') return; const cx = C + (i - (n - 1) / 2) * p, cy = C + (j - (m - 1) / 2) * p;
+		out.push(t[0] === 'p' ? knob(cx, cy, r, +t.slice(1), w, false) : knob(cx, cy, r, ang[t], w, true));
+	}));
+	return U(...out);
+};
+
+/**
+ * The disc radius that makes n discs and n − 1 gaps span 448.
+ *
+ * @param {number} n Discs across.
+ * @param {number} g The gap.
+ * @returns {number} The radius.
+ */
+export const rFor = (n, g) => (448 - (n - 1) * g) / n / 2;
+
+/**
+ * A roof tile: a square of side a with a half disc on its far side, the cap pointing at `deg`, centred on the square.
+ *
+ * @param {number} cx The square's centre.
+ * @param {number} cy The square's centre.
+ * @param {number} a Its side.
+ * @param {number} [deg=90] Where the cap points (90: down).
+ * @returns {Shape} The tile.
+ */
+export const roofTile = (cx, cy, a, deg = 90) => rot(U(rect(cx - a / 2, cy - a / 2, a, a), geoDisc(cx, cy + a / 2, a / 2)), deg - 90, cx, cy);
+
+/**
+ * Tiles laid back to front, each over the ones before it and cut free of them by g.
+ *
+ * @param {readonly Geom[]} list The tiles, back first.
+ * @param {number} g The gap.
+ * @returns {Geom} The stack.
+ */
+export const layered = (list, g) => list.reduce((acc, t) => (acc.length ? over(acc, t, g) : t), []);
+
+/**
+ * A triangle's corner points (apex up by default), circumradius R, centred on (cx, cy).
+ *
+ * @param {number} cx The centre.
+ * @param {number} cy The centre.
+ * @param {number} R The circumradius.
+ * @param {number} [deg=-90] The first corner's angle.
+ * @returns {Point[]} The three corners.
+ */
+export const triPts = (cx, cy, R, deg = -90) => [0, 1, 2].map((k) => polar(R, deg + k * 120, cx, cy));
+
+/**
+ * Half a disc: the half on the side `sideDeg` points to.
+ *
+ * @param {number} cx The centre.
+ * @param {number} cy The centre.
+ * @param {number} r The radius.
+ * @param {number} sideDeg The direction of the half kept (90: the lower half).
+ * @returns {Shape} The half disc.
+ */
+export const halfDisc = (cx, cy, r, sideDeg) => I(geoDisc(cx, cy, r), rot(rect(cx - r - 2, cy, 2 * r + 4, r + 2), sideDeg - 90, cx, cy));
+
+/** The split disc's radius. */
+export const R7 = 224;
+
+/**
+ * The disc (radius R7, centred) parted along the polyline L by g, each half's rim moved by sa / sb: the cut stays put, so
+ * the gap stays g.
+ *
+ * @param {readonly Point[]} L The cut.
+ * @param {number} g The gap.
+ * @param {readonly number[]} sa How far the rim on the left side moves.
+ * @param {readonly number[]} sb How far the rim on the right side moves.
+ * @returns {Shape} The two halves.
+ */
+export const splitDisc = (L, g, sa, sb) => {
+	const z = stroke(L, g, { chunk: 4 }), d = (o) => geoDisc(C + o[0], C + o[1], R7);
+	return U(D(I(d(sa), side(L, 1)), z), D(I(d(sb), side(L, -1)), z));
+};
+
+/** A roof tile's side in scales(). */
+export const SA = 150;
+
+/**
+ * Roof tiles at lattice points (i, j), pitch pi·a across and pj·a down (under 1, so each cap lies over the tile below and
+ * the tile beside), caps pointing down, the lattice turned by deg and laid back to front, the far rows first. A tile
+ * listed in `up` faces back up and is laid last, its cap over the tile above it.
+ *
+ * @param {readonly Point[]} cells The lattice points.
+ * @param {number} g The gap.
+ * @param {{ a?: number, pi?: number, pj?: number, deg?: number, up?: readonly Point[] }} [o] The tile side (150), the
+ *   pitches (0.75), the turn (45) and the tiles that face up.
+ * @returns {Shape} The scales.
+ */
+export const scales = (cells, g, { a = 150, pi = 0.75, pj = 0.75, deg = 45, up = [] } = {}) => {
+	const isUp = ([i, j]) => up.some(([ui, uj]) => ui === i && uj === j);
+	const list = cells.slice().sort((p, q) => isUp(p) - isUp(q) || q[1] - p[1] || q[0] - p[0]);
+	return rot(layered(list.map((c) => roofTile(C + c[0] * a * pi, C + c[1] * a * pj, a, isUp(c) ? -90 : 90)), g), deg);
+};
+
+/** The nine points of a 3 × 3 lattice, row by row. */
+export const grid3 = [0, 1, 2].flatMap((j) => [0, 1, 2].map((i) => [i, j]));

package/src/forms/hooks.d.ts

@@ -0,0 +1,40 @@
+import type { Point, Shape } from '../geometry/types.js';
+
+/** A hook: the end it grows from, the neighbour's cap centre it wraps, and its sweep (or end angle e and past). */
+export interface Hook {
+	end?: 0 | 1;
+	c: readonly number[];
+	rn?: number;
+	sw?: number;
+	e?: number;
+	past?: number;
+	t0?: number;
+	t1?: number;
+}
+
+/** The capsule's width (150). */
+export const HOOK_W: number;
+/** The point d from p at angle a (degrees). */
+export function hookAt(p: readonly number[], a: number, d: number): Point;
+/** Where a cap centre sits to hook the neighbour cap at c, at angle a. */
+export function kiss(c: readonly number[], a: number, g: number, r?: number, rn?: number): Point;
+/** A curl: a band of inner radius ri about c, from a0 sweeping sw, tapering t0 → t1, round tip. */
+export function curl(c: readonly number[], ri: number, a0: number, sw: number, t0: number, t1: number, n?: number): Shape;
+/** A capsule along pts with hooks, its curl roots filleted. */
+export function piece(pts: readonly Point[], hooks?: readonly Hook[], o?: { w?: number; bend?: number; g?: number; soft?: number; whole?: boolean }): Shape;
+/** The Track band's width for the gap g (74 at 22). */
+export function TB(g: number): number;
+/** A piece's Track build: its centreline run round each hook, as two tracks. */
+export function trackPiece(pts: readonly Point[], hooks?: readonly Hook[], o?: { g?: number; bend?: number }): Shape;
+/** Points along an arc about c, radius r, from a0 to a1 degrees. */
+export function arc(c: readonly number[], r: number, a0: number, a1: number, n?: number): Point[];
+/** A neighbour's end: its cap centre and the angle it faces. */
+export function endOf(pts: readonly Point[], end?: 0 | 1): { c: Point; e: number };
+/** Every point of every ring of a shape. */
+export function pts0(s: Shape): Point[];
+/** join()'s check switch: with `on`, it logs pieces closer than the gap. */
+export const hookCheck: { on: boolean };
+/** The pieces as one shape, checked when hookCheck.on. */
+export function join(g: number, ...ps: Shape[]): Shape;
+/** A Track piece's end: c + (TB(g) + g) along d ± 90°. */
+export function tq(c: readonly number[], d: number, side: number, g: number): Point;

package/src/forms/hooks.js

@@ -0,0 +1,204 @@
+/**
+ * Bold hooks: capsules whose round end runs on into a curl that wraps a neighbour's round end, the gap exact all round,
+ * and their Track build (the same layout drawn as two tracks). Angles are degrees, 0 right, 90 down. From the Logomarks
+ * tools (hookparts.mjs, batch 214, "Bold · Hooks", and its editions in batch 220).
+ */
+import { I, U, circle, fillet, pill, poly, rad, soften, stroke, tracks } from '../geometry/index.js';
+
+/** @typedef {import('../geometry/types.js').Point} Point */
+/** @typedef {import('../geometry/types.js').Shape} Shape */
+/** @typedef {import('../geometry/types.js').Geom} Geom */
+
+/**
+ * A hook: the end of a piece it grows from, the neighbour's cap centre it wraps, and how far it sweeps.
+ *
+ * @typedef {object} Hook
+ * @property {0 | 1} [end] The end it grows from: 0 the first point, 1 (the default) the last.
+ * @property {readonly number[]} c The neighbour's cap centre.
+ * @property {number} [rn] The neighbour's cap radius (HOOK_W / 2).
+ * @property {number} [sw] The sweep, degrees; or give `e`.
+ * @property {number} [e] The angle the curl should end at (the neighbour's end direction), when `sw` isn't given.
+ * @property {number} [past] Degrees past `e`.
+ * @property {number} [t0] The curl's width at its root (the piece's width).
+ * @property {number} [t1] Its width at the tip (0.44 of the piece's width).
+ */
+
+/** The capsule's width. */
+export const HOOK_W = 150;
+
+/**
+ * The point d from p at angle a.
+ *
+ * @param {readonly number[]} p The point.
+ * @param {number} a The angle, degrees.
+ * @param {number} d The distance.
+ * @returns {Point} The point reached.
+ */
+export const hookAt = (p, a, d) => [p[0] + d * Math.cos(rad(a)), p[1] + d * Math.sin(rad(a))];
+
+/**
+ * The angle from p to q, degrees.
+ *
+ * @param {readonly number[]} p From.
+ * @param {readonly number[]} q To.
+ * @returns {number} The angle.
+ */
+const ang = (p, q) => (Math.atan2(q[1] - p[1], q[0] - p[0]) * 180) / Math.PI;
+
+/**
+ * The distance from p to q.
+ *
+ * @param {readonly number[]} p From.
+ * @param {readonly number[]} q To.
+ * @returns {number} The distance.
+ */
+const dist = (p, q) => Math.hypot(q[0] - p[0], q[1] - p[1]);
+
+/**
+ * Where a piece's cap centre sits to hook the neighbour cap at c: at angle a from c, the two caps and the gap apart.
+ *
+ * @param {readonly number[]} c The neighbour's cap centre.
+ * @param {number} a The angle from it, degrees.
+ * @param {number} g The gap.
+ * @param {number} [r=HOOK_W / 2] This cap's radius.
+ * @param {number} [rn=HOOK_W / 2] The neighbour's.
+ * @returns {Point} The cap centre.
+ */
+export const kiss = (c, a, g, r = HOOK_W / 2, rn = HOOK_W / 2) => hookAt(c, a, r + rn + g);
+
+/**
+ * The curl: a band whose inner edge is radius ri about c, from angle a0 sweeping sw degrees, tapering t0 → t1, with a
+ * round tip.
+ *
+ * @param {readonly number[]} c The centre.
+ * @param {number} ri The inner radius.
+ * @param {number} a0 The start angle, degrees.
+ * @param {number} sw The sweep, degrees.
+ * @param {number} t0 The width at the start.
+ * @param {number} t1 The width at the tip.
+ * @param {number} [n=120] Steps along it.
+ * @returns {Shape} The curl.
+ */
+export const curl = (c, ri, a0, sw, t0, t1, n = 120) => {
+	const inner = [], outer = [];
+	for (let i = 0; i <= n; i++) { const f = i / n, a = a0 + sw * f, t = t1 + (t0 - t1) * (1 - f) ** 2; inner.push(hookAt(c, a, ri)); outer.push(hookAt(c, a, ri + t)); }
+	return U(poly([...inner, ...outer.reverse()]), circle(...hookAt(c, a0 + sw, ri + t1 / 2), t1 / 2, 120));
+};
+
+/**
+ * A piece: a capsule w wide along `pts` (corners filleted by `bend`), with hooks. Each hook names the end it grows from,
+ * the neighbour's cap centre and the sweep; it logs when the end isn't a kiss from the neighbour. The root of each curl is
+ * filleted (`soft`) where it leaves the round end, and only there, so a same-piece gap under 2·soft (a bowl's tip near its
+ * stem) doesn't close up; `whole` fillets every inner corner of a piece with no such gap.
+ *
+ * @param {readonly Point[]} pts The capsule's centreline.
+ * @param {readonly Hook[]} [hooks=[]] Its hooks.
+ * @param {{ w?: number, bend?: number, g?: number, soft?: number, whole?: boolean }} [o] Width (HOOK_W), corner fillet
+ *   (90), gap (22), root fillet (40), and whether to fillet every inner corner.
+ * @returns {Shape} The piece.
+ */
+export const piece = (pts, hooks = [], { w = HOOK_W, bend = 90, g = 22, soft = 40, whole = false } = {}) => {
+	const body = pts.length === 2 ? pill(pts[0], pts[1], w) : stroke(bend ? fillet(pts, bend) : pts, w, { roundCaps: true, chunk: 8 });
+	const curls = hooks.map(({ end = 1, c, rn = HOOK_W / 2, sw, e, past = 0, t0 = w, t1 = 0.44 * w }) => {
+		const q = end ? pts.at(-1) : pts[0];
+		const d = dist(c, q), want = w / 2 + rn + g; if (Math.abs(d - want) > 0.5) console.log(`  hook off by ${(d - want).toFixed(1)}`);
+		const a0 = ang(c, q); if (sw == null) { const dd = ((e - a0 + 540) % 360) - 180; sw = dd + Math.sign(dd) * past; }
+		return curl(c, rn + g, a0, sw, t0, t1);
+	});
+	const roots = hooks.map(({ end = 1 }) => circle(...(end ? pts.at(-1) : pts[0]), 0.9 * w, 160));
+	if (soft && whole) return soften(U(body, ...curls), soft, 0);
+	return soft && roots.length ? U(body, ...curls, I(soften(U(body, ...curls), soft, 0), ...(roots.length > 1 ? [U(...roots)] : roots))) : U(body, ...curls);
+};
+
+/**
+ * The Track band's width for the gap g: 74 at 22, so the Track build lands on the house Track rules once fitted. Pass it
+ * as `r` and `rn` to kiss() for a Track layout.
+ *
+ * @param {number} g The gap.
+ * @returns {number} The band width.
+ */
+export const TB = (g) => (74 * g) / 22;
+
+/**
+ * The Track build of a piece: its centreline run on round each hook's neighbour (at the kiss distance, so the curl's inner
+ * track clears the neighbour's tracks by g), drawn as two tracks 26 wide at pitch 48, both scaled with g.
+ *
+ * @param {readonly Point[]} pts The centreline.
+ * @param {readonly Hook[]} [hooks=[]] Its hooks (`end`, `c`, `sw` or `e` and `past`).
+ * @param {{ g?: number, bend?: number }} [o] The gap (22) and the corner fillet (60).
+ * @returns {Shape} The two tracks.
+ */
+export const trackPiece = (pts, hooks = [], { g = 22, bend = 60 } = {}) => {
+	let path = pts.slice();
+	for (const { end = 1, c, sw: sw0, e, past = 0 } of hooks) {
+		if (!end) path = path.slice().reverse(); const q = path.at(-1), a0 = ang(c, q);
+		let sw = sw0; if (sw == null) { const dd = ((e - a0 + 540) % 360) - 180; sw = dd + Math.sign(dd) * past; }
+		path = [...path, ...arc(c, dist(c, q), a0, a0 + sw, Math.max(8, Math.ceil(Math.abs(sw) / 4))).slice(1)];
+	}
+	return tracks(bend ? fillet(path, bend) : path, { n: 2, pitch: (48 * g) / 22, w: (26 * g) / 22 });
+};
+
+/**
+ * Points along an arc about c, radius r, from a0 to a1 degrees.
+ *
+ * @param {readonly number[]} c The centre.
+ * @param {number} r The radius.
+ * @param {number} a0 The start angle.
+ * @param {number} a1 The end angle.
+ * @param {number} [n=60] Steps.
+ * @returns {Point[]} n + 1 points.
+ */
+export const arc = (c, r, a0, a1, n = 60) => [...Array(n + 1)].map((_, i) => hookAt(c, a0 + ((a1 - a0) * i) / n, r));
+
+/**
+ * A neighbour's end, for a hook: its cap centre and the way the end faces.
+ *
+ * @param {readonly Point[]} pts The neighbour's centreline.
+ * @param {0 | 1} [end=1] Which end.
+ * @returns {{ c: Point, e: number }} The cap centre and the angle the end faces.
+ */
+export const endOf = (pts, end = 1) => (end ? { c: pts.at(-1), e: ang(pts.at(-2), pts.at(-1)) } : { c: pts[0], e: ang(pts[1], pts[0]) });
+
+/**
+ * Every point of every ring of a shape.
+ *
+ * @param {Shape} s The shape.
+ * @returns {Point[]} The points.
+ */
+export const pts0 = (s) => s.flatMap((pg) => pg.flatMap((r) => r));
+
+/**
+ * The least distance between two shapes' outline points.
+ *
+ * @param {Shape} a One shape.
+ * @param {Shape} b The other.
+ * @returns {number} The distance.
+ */
+const near = (a, b) => { let m = 1e9; const pa = pts0(a), pb = pts0(b); for (const p of pa) for (const q of pb) { const d = (p[0] - q[0]) ** 2 + (p[1] - q[1]) ** 2; if (d < m) m = d; } return Math.sqrt(m); };
+
+/** join()'s check: set `on` to have it log any two pieces closer than the gap. */
+export const hookCheck = { on: false };
+
+/**
+ * The pieces as one shape; with hookCheck.on, it logs any two that come closer than the gap.
+ *
+ * @param {number} g The gap.
+ * @param {...Shape} ps The pieces.
+ * @returns {Shape} Their union.
+ */
+export const join = (g, ...ps) => {
+	if (hookCheck.on) for (let i = 0; i < ps.length; i++) for (let j = i + 1; j < ps.length; j++) { const d = near(ps[i], ps[j]); if (d < g - 0.6) console.log(`  pieces ${i},${j} only ${d.toFixed(1)} apart (g ${g.toFixed(1)})`); }
+	return U(...ps);
+};
+
+/**
+ * For the Track build: a straight run must enter the curl on its tangent (a corner there kinks the outer track), so the
+ * piece's end sits a quarter turn round from where the bold build puts it: c + (TB(g) + g) along d ± 90°.
+ *
+ * @param {readonly number[]} c The neighbour's cap centre.
+ * @param {number} d The run's direction, degrees.
+ * @param {number} side Which side: 1 or −1.
+ * @param {number} g The gap.
+ * @returns {Point} The piece's end.
+ */
+export const tq = (c, d, side, g) => hookAt(c, d + side * 90, TB(g) + g);

package/src/forms/index.d.ts

@@ -0,0 +1,22 @@
+export * from './geo.js';
+export * from './discs.js';
+export * from './hooks.js';
+export * from './jog.js';
+export * from './tech.js';
+export * from './emblems.js';
+export * from './shatter.js';
+export * from './slats.js';
+export * from './flow.js';
+export * from './folds.js';
+export * from './swash.js';
+export * from './ref.js';
+export * from './tracks.js';
+export * from './lines.js';
+export type { Hook } from './hooks.js';
+export type { JogArm } from './jog.js';
+export type { Rail, Shard, ShardMove } from './shatter.js';
+export type { Slat, SlatRowOptions, SlatEdges } from './slats.js';
+export type { FlowOptions } from './flow.js';
+export type { SwashOptions } from './swash.js';
+export type { StripeEdge } from './ref.js';
+export type { TrackKit } from './tracks.js';

package/src/forms/index.js

@@ -0,0 +1,24 @@
+/**
+ * @module @logomarks/core/forms
+ *
+ * The constructions the Bold, Line and Track families are drawn with, on the 512 canvas with the house gap: needle
+ * gaps, knobs and split discs (geo), one disc cut so a moved piece keeps its gap (discs), capsules whose ends curl round
+ * a neighbour (hooks), jogged bursts and chamfer checkers (jog), sparkles, ribbons and keyed chevrons (tech), the split
+ * emblem's horizon and grounds (emblems), a form breaking into shards (shatter), turning slats, flow grids, fold seams
+ * and straps, swashes, rotation, stripes, guilloche and speed letters (ref), the Track editions' kit (tracks), and soft
+ * blobs, Rail lines, chamfered paths and interlocking overlaps (lines).
+ */
+export * from './geo.js';
+export * from './discs.js';
+export * from './hooks.js';
+export * from './jog.js';
+export * from './tech.js';
+export * from './emblems.js';
+export * from './shatter.js';
+export * from './slats.js';
+export * from './flow.js';
+export * from './folds.js';
+export * from './swash.js';
+export * from './ref.js';
+export * from './tracks.js';
+export * from './lines.js';

package/src/forms/jog.d.ts

@@ -0,0 +1,33 @@
+import type { Geom, Point, Polygon, Shape } from '../geometry/types.js';
+
+/** One jogged arm's options. */
+export interface JogArm {
+	r0?: number;
+	rb?: number;
+	breaks?: readonly number[];
+	R: number;
+	w: number;
+	g: number;
+	shift: number;
+	scarf?: number;
+	innerShift?: number;
+	cx?: number;
+	cy?: number;
+}
+
+/** The point `along` the axis at deg from (cx, cy), stepped `side` square to it. */
+export function axisAt(deg: number, along: number, side?: number, cx?: number, cy?: number): Point;
+/** A bar on the axis at deg from a0 to a1, w wide, `side` off the axis, its ends slanted by cut0 / cut1. */
+export function axisBar(deg: number, a0: number, a1: number, w: number, side?: number, o?: { cut0?: number; cut1?: number; cx?: number; cy?: number }): Polygon;
+/** One jogged arm: runs broken by g and stepped sideways. */
+export function jogArm(deg: number, o: JogArm): Shape;
+/** n jogged arms round the centre, the first at deg0. */
+export function jogBurst(n: number, deg0: number, o: JogArm, each?: (i: number) => Partial<JogArm>): Shape;
+/** A polygon with its corners cut at 45° by c (one or one per corner). */
+export function chamfer(pts: readonly Point[], c: number | readonly number[]): Polygon;
+/** A box from its corners, chamfered by c. */
+export function chamferBox(x0: number, y0: number, x1: number, y1: number, c?: number | readonly number[]): Polygon;
+/** A checker's dark cells, corner meetings cut so two squares are parted by exactly g. */
+export function checkerCells(x0: number, y0: number, p: number, cols: number, rows: number, g: number, o?: { parity?: 0 | 1; outer?: number; skip?: (i: number, j: number) => boolean }): Shape;
+/** Throws unless a stands at least g (less 0.5) clear of b. */
+export function assertClear(a: Geom, b: Geom, g: number, what?: string): void;